00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011 #define SWIGPYTHON
00012 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
00013
00014
00015
00016
00017
00018
00019 #ifndef SWIGTEMPLATEDISAMBIGUATOR
00020 # if defined(__SUNPRO_CC)
00021 # if (__SUNPRO_CC <= 0x560)
00022 # define SWIGTEMPLATEDISAMBIGUATOR template
00023 # else
00024 # define SWIGTEMPLATEDISAMBIGUATOR
00025 # endif
00026 # else
00027 # define SWIGTEMPLATEDISAMBIGUATOR
00028 # endif
00029 #endif
00030
00031
00032 #ifndef SWIGINLINE
00033 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
00034 # define SWIGINLINE inline
00035 # else
00036 # define SWIGINLINE
00037 # endif
00038 #endif
00039
00040
00041 #ifndef SWIGUNUSED
00042 # if defined(__GNUC__)
00043 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
00044 # define SWIGUNUSED __attribute__ ((__unused__))
00045 # else
00046 # define SWIGUNUSED
00047 # endif
00048 # elif defined(__ICC)
00049 # define SWIGUNUSED __attribute__ ((__unused__))
00050 # else
00051 # define SWIGUNUSED
00052 # endif
00053 #endif
00054
00055 #ifndef SWIGUNUSEDPARM
00056 # ifdef __cplusplus
00057 # define SWIGUNUSEDPARM(p)
00058 # else
00059 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
00060 # endif
00061 #endif
00062
00063
00064 #ifndef SWIGINTERN
00065 # define SWIGINTERN static SWIGUNUSED
00066 #endif
00067
00068
00069 #ifndef SWIGINTERNINLINE
00070 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
00071 #endif
00072
00073
00074 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
00075 # ifndef GCC_HASCLASSVISIBILITY
00076 # define GCC_HASCLASSVISIBILITY
00077 # endif
00078 #endif
00079
00080 #ifndef SWIGEXPORT
00081 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
00082 # if defined(STATIC_LINKED)
00083 # define SWIGEXPORT
00084 # else
00085 # define SWIGEXPORT __declspec(dllexport)
00086 # endif
00087 # else
00088 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
00089 # define SWIGEXPORT __attribute__ ((visibility("default")))
00090 # else
00091 # define SWIGEXPORT
00092 # endif
00093 # endif
00094 #endif
00095
00096
00097 #ifndef SWIGSTDCALL
00098 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
00099 # define SWIGSTDCALL __stdcall
00100 # else
00101 # define SWIGSTDCALL
00102 # endif
00103 #endif
00104
00105
00106 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
00107 # define _CRT_SECURE_NO_DEPRECATE
00108 #endif
00109
00110
00111
00112 #include <Python.h>
00113
00114
00115
00116
00117
00118
00119
00120
00121
00122
00123 #define SWIG_RUNTIME_VERSION "3"
00124
00125
00126 #ifdef SWIG_TYPE_TABLE
00127 # define SWIG_QUOTE_STRING(x) #x
00128 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
00129 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
00130 #else
00131 # define SWIG_TYPE_TABLE_NAME
00132 #endif
00133
00134
00135
00136
00137
00138
00139
00140
00141
00142
00143 #ifndef SWIGRUNTIME
00144 # define SWIGRUNTIME SWIGINTERN
00145 #endif
00146
00147 #ifndef SWIGRUNTIMEINLINE
00148 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
00149 #endif
00150
00151
00152 #ifndef SWIG_BUFFER_SIZE
00153 # define SWIG_BUFFER_SIZE 1024
00154 #endif
00155
00156
00157 #define SWIG_POINTER_DISOWN 0x1
00158
00159
00160 #define SWIG_POINTER_OWN 0x1
00161
00162
00163
00164
00165
00166
00167
00168
00169
00170
00171
00172
00173
00174
00175
00176
00177
00178
00179
00180
00181
00182
00183
00184
00185
00186
00187
00188
00189
00190
00191
00192
00193
00194
00195
00196
00197
00198
00199
00200
00201
00202
00203
00204
00205
00206
00207
00208
00209
00210
00211
00212
00213
00214
00215
00216
00217
00218
00219
00220
00221
00222
00223
00224
00225
00226
00227
00228
00229
00230
00231
00232
00233
00234
00235
00236
00237
00238
00239
00240
00241
00242
00243 #define SWIG_OK (0)
00244 #define SWIG_ERROR (-1)
00245 #define SWIG_IsOK(r) (r >= 0)
00246 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
00247
00248
00249 #define SWIG_CASTRANKLIMIT (1 << 8)
00250
00251 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
00252
00253 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
00254
00255 #define SWIG_BADOBJ (SWIG_ERROR)
00256 #define SWIG_OLDOBJ (SWIG_OK)
00257 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
00258 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
00259
00260 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
00261 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
00262 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
00263 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
00264 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
00265 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
00266
00267
00268
00269 #if defined(SWIG_CASTRANK_MODE)
00270 # ifndef SWIG_TypeRank
00271 # define SWIG_TypeRank unsigned long
00272 # endif
00273 # ifndef SWIG_MAXCASTRANK
00274 # define SWIG_MAXCASTRANK (2)
00275 # endif
00276 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
00277 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
00278 SWIGINTERNINLINE int SWIG_AddCast(int r) {
00279 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
00280 }
00281 SWIGINTERNINLINE int SWIG_CheckState(int r) {
00282 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
00283 }
00284 #else
00285 # define SWIG_AddCast
00286 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
00287 #endif
00288
00289
00290
00291
00292 #include <string.h>
00293
00294 #ifdef __cplusplus
00295 extern "C" {
00296 #endif
00297
00298 typedef void *(*swig_converter_func)(void *);
00299 typedef struct swig_type_info *(*swig_dycast_func)(void **);
00300
00301
00302 typedef struct swig_type_info {
00303 const char *name;
00304 const char *str;
00305 swig_dycast_func dcast;
00306 struct swig_cast_info *cast;
00307 void *clientdata;
00308 int owndata;
00309 } swig_type_info;
00310
00311
00312 typedef struct swig_cast_info {
00313 swig_type_info *type;
00314 swig_converter_func converter;
00315 struct swig_cast_info *next;
00316 struct swig_cast_info *prev;
00317 } swig_cast_info;
00318
00319
00320
00321
00322 typedef struct swig_module_info {
00323 swig_type_info **types;
00324 size_t size;
00325 struct swig_module_info *next;
00326 swig_type_info **type_initial;
00327 swig_cast_info **cast_initial;
00328 void *clientdata;
00329 } swig_module_info;
00330
00331
00332
00333
00334
00335
00336
00337
00338 SWIGRUNTIME int
00339 SWIG_TypeNameComp(const char *f1, const char *l1,
00340 const char *f2, const char *l2) {
00341 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
00342 while ((*f1 == ' ') && (f1 != l1)) ++f1;
00343 while ((*f2 == ' ') && (f2 != l2)) ++f2;
00344 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
00345 }
00346 return (l1 - f1) - (l2 - f2);
00347 }
00348
00349
00350
00351
00352
00353 SWIGRUNTIME int
00354 SWIG_TypeEquiv(const char *nb, const char *tb) {
00355 int equiv = 0;
00356 const char* te = tb + strlen(tb);
00357 const char* ne = nb;
00358 while (!equiv && *ne) {
00359 for (nb = ne; *ne; ++ne) {
00360 if (*ne == '|') break;
00361 }
00362 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
00363 if (*ne) ++ne;
00364 }
00365 return equiv;
00366 }
00367
00368
00369
00370
00371
00372 SWIGRUNTIME int
00373 SWIG_TypeCompare(const char *nb, const char *tb) {
00374 int equiv = 0;
00375 const char* te = tb + strlen(tb);
00376 const char* ne = nb;
00377 while (!equiv && *ne) {
00378 for (nb = ne; *ne; ++ne) {
00379 if (*ne == '|') break;
00380 }
00381 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
00382 if (*ne) ++ne;
00383 }
00384 return equiv;
00385 }
00386
00387
00388
00389 #define SWIG_TypeCheck_Template(comparison, ty) \
00390 if (ty) { \
00391 swig_cast_info *iter = ty->cast; \
00392 while (iter) { \
00393 if (comparison) { \
00394 if (iter == ty->cast) return iter; \
00395 \
00396 iter->prev->next = iter->next; \
00397 if (iter->next) \
00398 iter->next->prev = iter->prev; \
00399 iter->next = ty->cast; \
00400 iter->prev = 0; \
00401 if (ty->cast) ty->cast->prev = iter; \
00402 ty->cast = iter; \
00403 return iter; \
00404 } \
00405 iter = iter->next; \
00406 } \
00407 } \
00408 return 0
00409
00410
00411
00412
00413 SWIGRUNTIME swig_cast_info *
00414 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
00415 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
00416 }
00417
00418
00419 SWIGRUNTIME swig_cast_info *
00420 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
00421 SWIG_TypeCheck_Template(iter->type == from, into);
00422 }
00423
00424
00425
00426
00427 SWIGRUNTIMEINLINE void *
00428 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
00429 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
00430 }
00431
00432
00433
00434
00435 SWIGRUNTIME swig_type_info *
00436 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
00437 swig_type_info *lastty = ty;
00438 if (!ty || !ty->dcast) return ty;
00439 while (ty && (ty->dcast)) {
00440 ty = (*ty->dcast)(ptr);
00441 if (ty) lastty = ty;
00442 }
00443 return lastty;
00444 }
00445
00446
00447
00448
00449 SWIGRUNTIMEINLINE const char *
00450 SWIG_TypeName(const swig_type_info *ty) {
00451 return ty->name;
00452 }
00453
00454
00455
00456
00457
00458 SWIGRUNTIME const char *
00459 SWIG_TypePrettyName(const swig_type_info *type) {
00460
00461
00462
00463
00464 if (!type) return NULL;
00465 if (type->str != NULL) {
00466 const char *last_name = type->str;
00467 const char *s;
00468 for (s = type->str; *s; s++)
00469 if (*s == '|') last_name = s+1;
00470 return last_name;
00471 }
00472 else
00473 return type->name;
00474 }
00475
00476
00477
00478
00479 SWIGRUNTIME void
00480 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
00481 swig_cast_info *cast = ti->cast;
00482
00483 ti->clientdata = clientdata;
00484
00485 while (cast) {
00486 if (!cast->converter) {
00487 swig_type_info *tc = cast->type;
00488 if (!tc->clientdata) {
00489 SWIG_TypeClientData(tc, clientdata);
00490 }
00491 }
00492 cast = cast->next;
00493 }
00494 }
00495 SWIGRUNTIME void
00496 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
00497 SWIG_TypeClientData(ti, clientdata);
00498 ti->owndata = 1;
00499 }
00500
00501
00502
00503
00504
00505
00506
00507
00508
00509 SWIGRUNTIME swig_type_info *
00510 SWIG_MangledTypeQueryModule(swig_module_info *start,
00511 swig_module_info *end,
00512 const char *name) {
00513 swig_module_info *iter = start;
00514 do {
00515 if (iter->size) {
00516 register size_t l = 0;
00517 register size_t r = iter->size - 1;
00518 do {
00519
00520 register size_t i = (l + r) >> 1;
00521 const char *iname = iter->types[i]->name;
00522 if (iname) {
00523 register int compare = strcmp(name, iname);
00524 if (compare == 0) {
00525 return iter->types[i];
00526 } else if (compare < 0) {
00527 if (i) {
00528 r = i - 1;
00529 } else {
00530 break;
00531 }
00532 } else if (compare > 0) {
00533 l = i + 1;
00534 }
00535 } else {
00536 break;
00537 }
00538 } while (l <= r);
00539 }
00540 iter = iter->next;
00541 } while (iter != end);
00542 return 0;
00543 }
00544
00545
00546
00547
00548
00549
00550
00551
00552
00553
00554 SWIGRUNTIME swig_type_info *
00555 SWIG_TypeQueryModule(swig_module_info *start,
00556 swig_module_info *end,
00557 const char *name) {
00558
00559 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
00560 if (ret) {
00561 return ret;
00562 } else {
00563
00564
00565 swig_module_info *iter = start;
00566 do {
00567 register size_t i = 0;
00568 for (; i < iter->size; ++i) {
00569 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
00570 return iter->types[i];
00571 }
00572 iter = iter->next;
00573 } while (iter != end);
00574 }
00575
00576
00577 return 0;
00578 }
00579
00580
00581
00582
00583 SWIGRUNTIME char *
00584 SWIG_PackData(char *c, void *ptr, size_t sz) {
00585 static const char hex[17] = "0123456789abcdef";
00586 register const unsigned char *u = (unsigned char *) ptr;
00587 register const unsigned char *eu = u + sz;
00588 for (; u != eu; ++u) {
00589 register unsigned char uu = *u;
00590 *(c++) = hex[(uu & 0xf0) >> 4];
00591 *(c++) = hex[uu & 0xf];
00592 }
00593 return c;
00594 }
00595
00596
00597
00598
00599 SWIGRUNTIME const char *
00600 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
00601 register unsigned char *u = (unsigned char *) ptr;
00602 register const unsigned char *eu = u + sz;
00603 for (; u != eu; ++u) {
00604 register char d = *(c++);
00605 register unsigned char uu;
00606 if ((d >= '0') && (d <= '9'))
00607 uu = ((d - '0') << 4);
00608 else if ((d >= 'a') && (d <= 'f'))
00609 uu = ((d - ('a'-10)) << 4);
00610 else
00611 return (char *) 0;
00612 d = *(c++);
00613 if ((d >= '0') && (d <= '9'))
00614 uu |= (d - '0');
00615 else if ((d >= 'a') && (d <= 'f'))
00616 uu |= (d - ('a'-10));
00617 else
00618 return (char *) 0;
00619 *u = uu;
00620 }
00621 return c;
00622 }
00623
00624
00625
00626
00627 SWIGRUNTIME char *
00628 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
00629 char *r = buff;
00630 if ((2*sizeof(void *) + 2) > bsz) return 0;
00631 *(r++) = '_';
00632 r = SWIG_PackData(r,&ptr,sizeof(void *));
00633 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
00634 strcpy(r,name);
00635 return buff;
00636 }
00637
00638 SWIGRUNTIME const char *
00639 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
00640 if (*c != '_') {
00641 if (strcmp(c,"NULL") == 0) {
00642 *ptr = (void *) 0;
00643 return name;
00644 } else {
00645 return 0;
00646 }
00647 }
00648 return SWIG_UnpackData(++c,ptr,sizeof(void *));
00649 }
00650
00651 SWIGRUNTIME char *
00652 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
00653 char *r = buff;
00654 size_t lname = (name ? strlen(name) : 0);
00655 if ((2*sz + 2 + lname) > bsz) return 0;
00656 *(r++) = '_';
00657 r = SWIG_PackData(r,ptr,sz);
00658 if (lname) {
00659 strncpy(r,name,lname+1);
00660 } else {
00661 *r = 0;
00662 }
00663 return buff;
00664 }
00665
00666 SWIGRUNTIME const char *
00667 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
00668 if (*c != '_') {
00669 if (strcmp(c,"NULL") == 0) {
00670 memset(ptr,0,sz);
00671 return name;
00672 } else {
00673 return 0;
00674 }
00675 }
00676 return SWIG_UnpackData(++c,ptr,sz);
00677 }
00678
00679 #ifdef __cplusplus
00680 }
00681 #endif
00682
00683
00684 #define SWIG_UnknownError -1
00685 #define SWIG_IOError -2
00686 #define SWIG_RuntimeError -3
00687 #define SWIG_IndexError -4
00688 #define SWIG_TypeError -5
00689 #define SWIG_DivisionByZero -6
00690 #define SWIG_OverflowError -7
00691 #define SWIG_SyntaxError -8
00692 #define SWIG_ValueError -9
00693 #define SWIG_SystemError -10
00694 #define SWIG_AttributeError -11
00695 #define SWIG_MemoryError -12
00696 #define SWIG_NullReferenceError -13
00697
00698
00699
00700
00701
00702 #if PY_VERSION_HEX < 0x02020000
00703 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
00704 # define PyOS_snprintf _snprintf
00705 # else
00706 # define PyOS_snprintf snprintf
00707 # endif
00708 #endif
00709
00710
00711 #if PY_VERSION_HEX < 0x02020000
00712
00713 #ifndef SWIG_PYBUFFER_SIZE
00714 # define SWIG_PYBUFFER_SIZE 1024
00715 #endif
00716
00717 static PyObject *
00718 PyString_FromFormat(const char *fmt, ...) {
00719 va_list ap;
00720 char buf[SWIG_PYBUFFER_SIZE * 2];
00721 int res;
00722 va_start(ap, fmt);
00723 res = vsnprintf(buf, sizeof(buf), fmt, ap);
00724 va_end(ap);
00725 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
00726 }
00727 #endif
00728
00729
00730 #if PY_VERSION_HEX < 0x01060000
00731 # define PyObject_Del(op) PyMem_DEL((op))
00732 #endif
00733 #ifndef PyObject_DEL
00734 # define PyObject_DEL PyObject_Del
00735 #endif
00736
00737
00738 #if PY_VERSION_HEX < 0x02020000
00739 # ifndef PyExc_StopIteration
00740 # define PyExc_StopIteration PyExc_RuntimeError
00741 # endif
00742 # ifndef PyObject_GenericGetAttr
00743 # define PyObject_GenericGetAttr 0
00744 # endif
00745 #endif
00746
00747 #if PY_VERSION_HEX < 0x02010000
00748 # ifndef Py_NotImplemented
00749 # define Py_NotImplemented PyExc_RuntimeError
00750 # endif
00751 #endif
00752
00753
00754
00755 #if PY_VERSION_HEX < 0x02010000
00756 # ifndef PyString_AsStringAndSize
00757 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
00758 # endif
00759 #endif
00760
00761
00762 #if PY_VERSION_HEX < 0x02000000
00763 # ifndef PySequence_Size
00764 # define PySequence_Size PySequence_Length
00765 # endif
00766 #endif
00767
00768
00769
00770 #if PY_VERSION_HEX < 0x02030000
00771 static
00772 PyObject *PyBool_FromLong(long ok)
00773 {
00774 PyObject *result = ok ? Py_True : Py_False;
00775 Py_INCREF(result);
00776 return result;
00777 }
00778 #endif
00779
00780
00781
00782
00783 #if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)
00784 typedef int Py_ssize_t;
00785 # define PY_SSIZE_T_MAX INT_MAX
00786 # define PY_SSIZE_T_MIN INT_MIN
00787 #endif
00788
00789
00790
00791
00792
00793 SWIGRUNTIME PyObject*
00794 SWIG_Python_ErrorType(int code) {
00795 PyObject* type = 0;
00796 switch(code) {
00797 case SWIG_MemoryError:
00798 type = PyExc_MemoryError;
00799 break;
00800 case SWIG_IOError:
00801 type = PyExc_IOError;
00802 break;
00803 case SWIG_RuntimeError:
00804 type = PyExc_RuntimeError;
00805 break;
00806 case SWIG_IndexError:
00807 type = PyExc_IndexError;
00808 break;
00809 case SWIG_TypeError:
00810 type = PyExc_TypeError;
00811 break;
00812 case SWIG_DivisionByZero:
00813 type = PyExc_ZeroDivisionError;
00814 break;
00815 case SWIG_OverflowError:
00816 type = PyExc_OverflowError;
00817 break;
00818 case SWIG_SyntaxError:
00819 type = PyExc_SyntaxError;
00820 break;
00821 case SWIG_ValueError:
00822 type = PyExc_ValueError;
00823 break;
00824 case SWIG_SystemError:
00825 type = PyExc_SystemError;
00826 break;
00827 case SWIG_AttributeError:
00828 type = PyExc_AttributeError;
00829 break;
00830 default:
00831 type = PyExc_RuntimeError;
00832 }
00833 return type;
00834 }
00835
00836
00837 SWIGRUNTIME void
00838 SWIG_Python_AddErrorMsg(const char* mesg)
00839 {
00840 PyObject *type = 0;
00841 PyObject *value = 0;
00842 PyObject *traceback = 0;
00843
00844 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
00845 if (value) {
00846 PyObject *old_str = PyObject_Str(value);
00847 PyErr_Clear();
00848 Py_XINCREF(type);
00849 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
00850 Py_DECREF(old_str);
00851 Py_DECREF(value);
00852 } else {
00853 PyErr_Format(PyExc_RuntimeError, mesg);
00854 }
00855 }
00856
00857
00858
00859 #if defined(SWIG_PYTHON_NO_THREADS)
00860 # if defined(SWIG_PYTHON_THREADS)
00861 # undef SWIG_PYTHON_THREADS
00862 # endif
00863 #endif
00864 #if defined(SWIG_PYTHON_THREADS)
00865 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
00866 # if (PY_VERSION_HEX >= 0x02030000)
00867 # define SWIG_PYTHON_USE_GIL
00868 # endif
00869 # endif
00870 # if defined(SWIG_PYTHON_USE_GIL)
00871 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
00872 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
00873 # endif
00874 # ifdef __cplusplus
00875 class SWIG_Python_Thread_Block {
00876 bool status;
00877 PyGILState_STATE state;
00878 public:
00879 void end() { if (status) { PyGILState_Release(state); status = false;} }
00880 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
00881 ~SWIG_Python_Thread_Block() { end(); }
00882 };
00883 class SWIG_Python_Thread_Allow {
00884 bool status;
00885 PyThreadState *save;
00886 public:
00887 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
00888 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
00889 ~SWIG_Python_Thread_Allow() { end(); }
00890 };
00891 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
00892 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
00893 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
00894 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
00895 # else
00896 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
00897 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
00898 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
00899 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
00900 # endif
00901 # else
00902 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
00903 # define SWIG_PYTHON_INITIALIZE_THREADS
00904 # endif
00905 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
00906 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
00907 # endif
00908 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
00909 # define SWIG_PYTHON_THREAD_END_BLOCK
00910 # endif
00911 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
00912 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
00913 # endif
00914 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
00915 # define SWIG_PYTHON_THREAD_END_ALLOW
00916 # endif
00917 # endif
00918 #else
00919 # define SWIG_PYTHON_INITIALIZE_THREADS
00920 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
00921 # define SWIG_PYTHON_THREAD_END_BLOCK
00922 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
00923 # define SWIG_PYTHON_THREAD_END_ALLOW
00924 #endif
00925
00926
00927
00928
00929
00930 #ifdef __cplusplus
00931 extern "C" {
00932 #if 0
00933 }
00934 #endif
00935 #endif
00936
00937
00938
00939
00940
00941
00942 #define SWIG_PY_POINTER 4
00943 #define SWIG_PY_BINARY 5
00944
00945
00946 typedef struct swig_const_info {
00947 int type;
00948 char *name;
00949 long lvalue;
00950 double dvalue;
00951 void *pvalue;
00952 swig_type_info **ptype;
00953 } swig_const_info;
00954
00955 #ifdef __cplusplus
00956 #if 0
00957 {
00958 #endif
00959 }
00960 #endif
00961
00962
00963
00964
00965
00966
00967
00968
00969
00970
00971
00972
00973
00974
00975
00976
00977
00978 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
00979 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
00980 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
00981 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
00982 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
00983 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
00984 #define swig_owntype int
00985
00986
00987 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
00988 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
00989
00990
00991 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
00992 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
00993
00994
00995 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
00996 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
00997
00998
00999 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
01000 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
01001
01002
01003
01004
01005 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
01006 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
01007 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
01008
01009 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
01010 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
01011 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
01012 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
01013 #define SWIG_fail goto fail
01014
01015
01016
01017
01018
01019
01020 SWIGINTERN void
01021 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
01022 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
01023 PyErr_SetObject(errtype, obj);
01024 Py_DECREF(obj);
01025 SWIG_PYTHON_THREAD_END_BLOCK;
01026 }
01027
01028 SWIGINTERN void
01029 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
01030 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
01031 PyErr_SetString(errtype, (char *) msg);
01032 SWIG_PYTHON_THREAD_END_BLOCK;
01033 }
01034
01035 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
01036
01037
01038
01039 SWIGINTERN void
01040 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
01041 PyDict_SetItemString(d, (char*) name, obj);
01042 Py_DECREF(obj);
01043 }
01044
01045
01046
01047 SWIGINTERN PyObject*
01048 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
01049 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
01050 if (!result) {
01051 result = obj;
01052 } else if (result == Py_None) {
01053 Py_DECREF(result);
01054 result = obj;
01055 } else {
01056 if (!PyList_Check(result)) {
01057 PyObject *o2 = result;
01058 result = PyList_New(1);
01059 PyList_SetItem(result, 0, o2);
01060 }
01061 PyList_Append(result,obj);
01062 Py_DECREF(obj);
01063 }
01064 return result;
01065 #else
01066 PyObject* o2;
01067 PyObject* o3;
01068 if (!result) {
01069 result = obj;
01070 } else if (result == Py_None) {
01071 Py_DECREF(result);
01072 result = obj;
01073 } else {
01074 if (!PyTuple_Check(result)) {
01075 o2 = result;
01076 result = PyTuple_New(1);
01077 PyTuple_SET_ITEM(result, 0, o2);
01078 }
01079 o3 = PyTuple_New(1);
01080 PyTuple_SET_ITEM(o3, 0, obj);
01081 o2 = result;
01082 result = PySequence_Concat(o2, o3);
01083 Py_DECREF(o2);
01084 Py_DECREF(o3);
01085 }
01086 return result;
01087 #endif
01088 }
01089
01090
01091
01092 SWIGINTERN int
01093 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
01094 {
01095 if (!args) {
01096 if (!min && !max) {
01097 return 1;
01098 } else {
01099 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
01100 name, (min == max ? "" : "at least "), min);
01101 return 0;
01102 }
01103 }
01104 if (!PyTuple_Check(args)) {
01105 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
01106 return 0;
01107 } else {
01108 register int l = PyTuple_GET_SIZE(args);
01109 if (l < min) {
01110 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
01111 name, (min == max ? "" : "at least "), min, l);
01112 return 0;
01113 } else if (l > max) {
01114 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
01115 name, (min == max ? "" : "at most "), max, l);
01116 return 0;
01117 } else {
01118 register int i;
01119 for (i = 0; i < l; ++i) {
01120 objs[i] = PyTuple_GET_ITEM(args, i);
01121 }
01122 for (; l < max; ++l) {
01123 objs[l] = 0;
01124 }
01125 return i + 1;
01126 }
01127 }
01128 }
01129
01130
01131 #if PY_VERSION_HEX >= 0x02020000
01132 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
01133 #else
01134 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
01135 #endif
01136
01137
01138
01139
01140
01141 #ifdef __cplusplus
01142 #define SWIG_STATIC_POINTER(var) var
01143 #else
01144 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
01145 #endif
01146
01147
01148
01149
01150
01151
01152 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
01153 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
01154
01155 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
01156
01157 #ifdef __cplusplus
01158 extern "C" {
01159 #if 0
01160 }
01161 #endif
01162 #endif
01163
01164
01165 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
01166 # ifndef SWIG_PYTHON_NO_BUILD_NONE
01167 # ifndef SWIG_PYTHON_BUILD_NONE
01168 # define SWIG_PYTHON_BUILD_NONE
01169 # endif
01170 # endif
01171 #endif
01172
01173 #ifdef SWIG_PYTHON_BUILD_NONE
01174 # ifdef Py_None
01175 # undef Py_None
01176 # define Py_None SWIG_Py_None()
01177 # endif
01178 SWIGRUNTIMEINLINE PyObject *
01179 _SWIG_Py_None(void)
01180 {
01181 PyObject *none = Py_BuildValue((char*)"");
01182 Py_DECREF(none);
01183 return none;
01184 }
01185 SWIGRUNTIME PyObject *
01186 SWIG_Py_None(void)
01187 {
01188 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
01189 return none;
01190 }
01191 #endif
01192
01193
01194
01195 SWIGRUNTIMEINLINE PyObject *
01196 SWIG_Py_Void(void)
01197 {
01198 PyObject *none = Py_None;
01199 Py_INCREF(none);
01200 return none;
01201 }
01202
01203
01204
01205 typedef struct {
01206 PyObject *klass;
01207 PyObject *newraw;
01208 PyObject *newargs;
01209 PyObject *destroy;
01210 int delargs;
01211 int implicitconv;
01212 } PySwigClientData;
01213
01214 SWIGRUNTIMEINLINE int
01215 SWIG_Python_CheckImplicit(swig_type_info *ty)
01216 {
01217 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
01218 return data ? data->implicitconv : 0;
01219 }
01220
01221 SWIGRUNTIMEINLINE PyObject *
01222 SWIG_Python_ExceptionType(swig_type_info *desc) {
01223 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
01224 PyObject *klass = data ? data->klass : 0;
01225 return (klass ? klass : PyExc_RuntimeError);
01226 }
01227
01228
01229 SWIGRUNTIME PySwigClientData *
01230 PySwigClientData_New(PyObject* obj)
01231 {
01232 if (!obj) {
01233 return 0;
01234 } else {
01235 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
01236
01237 data->klass = obj;
01238 Py_INCREF(data->klass);
01239
01240 if (PyClass_Check(obj)) {
01241 data->newraw = 0;
01242 data->newargs = obj;
01243 Py_INCREF(obj);
01244 } else {
01245 #if (PY_VERSION_HEX < 0x02020000)
01246 data->newraw = 0;
01247 #else
01248 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
01249 #endif
01250 if (data->newraw) {
01251 Py_INCREF(data->newraw);
01252 data->newargs = PyTuple_New(1);
01253 PyTuple_SetItem(data->newargs, 0, obj);
01254 } else {
01255 data->newargs = obj;
01256 }
01257 Py_INCREF(data->newargs);
01258 }
01259
01260 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
01261 if (PyErr_Occurred()) {
01262 PyErr_Clear();
01263 data->destroy = 0;
01264 }
01265 if (data->destroy) {
01266 int flags;
01267 Py_INCREF(data->destroy);
01268 flags = PyCFunction_GET_FLAGS(data->destroy);
01269 #ifdef METH_O
01270 data->delargs = !(flags & (METH_O));
01271 #else
01272 data->delargs = 0;
01273 #endif
01274 } else {
01275 data->delargs = 0;
01276 }
01277 data->implicitconv = 0;
01278 return data;
01279 }
01280 }
01281
01282 SWIGRUNTIME void
01283 PySwigClientData_Del(PySwigClientData* data)
01284 {
01285 Py_XDECREF(data->newraw);
01286 Py_XDECREF(data->newargs);
01287 Py_XDECREF(data->destroy);
01288 }
01289
01290
01291
01292 typedef struct {
01293 PyObject_HEAD
01294 void *ptr;
01295 swig_type_info *ty;
01296 int own;
01297 PyObject *next;
01298 } PySwigObject;
01299
01300 SWIGRUNTIME PyObject *
01301 PySwigObject_long(PySwigObject *v)
01302 {
01303 return PyLong_FromVoidPtr(v->ptr);
01304 }
01305
01306 SWIGRUNTIME PyObject *
01307 PySwigObject_format(const char* fmt, PySwigObject *v)
01308 {
01309 PyObject *res = NULL;
01310 PyObject *args = PyTuple_New(1);
01311 if (args) {
01312 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
01313 PyObject *ofmt = PyString_FromString(fmt);
01314 if (ofmt) {
01315 res = PyString_Format(ofmt,args);
01316 Py_DECREF(ofmt);
01317 }
01318 Py_DECREF(args);
01319 }
01320 }
01321 return res;
01322 }
01323
01324 SWIGRUNTIME PyObject *
01325 PySwigObject_oct(PySwigObject *v)
01326 {
01327 return PySwigObject_format("%o",v);
01328 }
01329
01330 SWIGRUNTIME PyObject *
01331 PySwigObject_hex(PySwigObject *v)
01332 {
01333 return PySwigObject_format("%x",v);
01334 }
01335
01336 SWIGRUNTIME PyObject *
01337 #ifdef METH_NOARGS
01338 PySwigObject_repr(PySwigObject *v)
01339 #else
01340 PySwigObject_repr(PySwigObject *v, PyObject *args)
01341 #endif
01342 {
01343 const char *name = SWIG_TypePrettyName(v->ty);
01344 PyObject *hex = PySwigObject_hex(v);
01345 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
01346 Py_DECREF(hex);
01347 if (v->next) {
01348 #ifdef METH_NOARGS
01349 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
01350 #else
01351 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
01352 #endif
01353 PyString_ConcatAndDel(&repr,nrep);
01354 }
01355 return repr;
01356 }
01357
01358 SWIGRUNTIME int
01359 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
01360 {
01361 #ifdef METH_NOARGS
01362 PyObject *repr = PySwigObject_repr(v);
01363 #else
01364 PyObject *repr = PySwigObject_repr(v, NULL);
01365 #endif
01366 if (repr) {
01367 fputs(PyString_AsString(repr), fp);
01368 Py_DECREF(repr);
01369 return 0;
01370 } else {
01371 return 1;
01372 }
01373 }
01374
01375 SWIGRUNTIME PyObject *
01376 PySwigObject_str(PySwigObject *v)
01377 {
01378 char result[SWIG_BUFFER_SIZE];
01379 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
01380 PyString_FromString(result) : 0;
01381 }
01382
01383 SWIGRUNTIME int
01384 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
01385 {
01386 void *i = v->ptr;
01387 void *j = w->ptr;
01388 return (i < j) ? -1 : ((i > j) ? 1 : 0);
01389 }
01390
01391 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
01392
01393 SWIGRUNTIME PyTypeObject*
01394 PySwigObject_type(void) {
01395 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
01396 return type;
01397 }
01398
01399 SWIGRUNTIMEINLINE int
01400 PySwigObject_Check(PyObject *op) {
01401 return ((op)->ob_type == PySwigObject_type())
01402 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
01403 }
01404
01405 SWIGRUNTIME PyObject *
01406 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
01407
01408 SWIGRUNTIME void
01409 PySwigObject_dealloc(PyObject *v)
01410 {
01411 PySwigObject *sobj = (PySwigObject *) v;
01412 PyObject *next = sobj->next;
01413 if (sobj->own) {
01414 swig_type_info *ty = sobj->ty;
01415 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
01416 PyObject *destroy = data ? data->destroy : 0;
01417 if (destroy) {
01418
01419 PyObject *res;
01420 if (data->delargs) {
01421
01422 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
01423 res = SWIG_Python_CallFunctor(destroy, tmp);
01424 Py_DECREF(tmp);
01425 } else {
01426 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
01427 PyObject *mself = PyCFunction_GET_SELF(destroy);
01428 res = ((*meth)(mself, v));
01429 }
01430 Py_XDECREF(res);
01431 } else {
01432 const char *name = SWIG_TypePrettyName(ty);
01433 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
01434 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
01435 #endif
01436 }
01437 }
01438 Py_XDECREF(next);
01439 PyObject_DEL(v);
01440 }
01441
01442 SWIGRUNTIME PyObject*
01443 PySwigObject_append(PyObject* v, PyObject* next)
01444 {
01445 PySwigObject *sobj = (PySwigObject *) v;
01446 #ifndef METH_O
01447 PyObject *tmp = 0;
01448 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
01449 next = tmp;
01450 #endif
01451 if (!PySwigObject_Check(next)) {
01452 return NULL;
01453 }
01454 sobj->next = next;
01455 Py_INCREF(next);
01456 return SWIG_Py_Void();
01457 }
01458
01459 SWIGRUNTIME PyObject*
01460 #ifdef METH_NOARGS
01461 PySwigObject_next(PyObject* v)
01462 #else
01463 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
01464 #endif
01465 {
01466 PySwigObject *sobj = (PySwigObject *) v;
01467 if (sobj->next) {
01468 Py_INCREF(sobj->next);
01469 return sobj->next;
01470 } else {
01471 return SWIG_Py_Void();
01472 }
01473 }
01474
01475 SWIGINTERN PyObject*
01476 #ifdef METH_NOARGS
01477 PySwigObject_disown(PyObject *v)
01478 #else
01479 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
01480 #endif
01481 {
01482 PySwigObject *sobj = (PySwigObject *)v;
01483 sobj->own = 0;
01484 return SWIG_Py_Void();
01485 }
01486
01487 SWIGINTERN PyObject*
01488 #ifdef METH_NOARGS
01489 PySwigObject_acquire(PyObject *v)
01490 #else
01491 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
01492 #endif
01493 {
01494 PySwigObject *sobj = (PySwigObject *)v;
01495 sobj->own = SWIG_POINTER_OWN;
01496 return SWIG_Py_Void();
01497 }
01498
01499 SWIGINTERN PyObject*
01500 PySwigObject_own(PyObject *v, PyObject *args)
01501 {
01502 PyObject *val = 0;
01503 #if (PY_VERSION_HEX < 0x02020000)
01504 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
01505 #else
01506 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
01507 #endif
01508 {
01509 return NULL;
01510 }
01511 else
01512 {
01513 PySwigObject *sobj = (PySwigObject *)v;
01514 PyObject *obj = PyBool_FromLong(sobj->own);
01515 if (val) {
01516 #ifdef METH_NOARGS
01517 if (PyObject_IsTrue(val)) {
01518 PySwigObject_acquire(v);
01519 } else {
01520 PySwigObject_disown(v);
01521 }
01522 #else
01523 if (PyObject_IsTrue(val)) {
01524 PySwigObject_acquire(v,args);
01525 } else {
01526 PySwigObject_disown(v,args);
01527 }
01528 #endif
01529 }
01530 return obj;
01531 }
01532 }
01533
01534 #ifdef METH_O
01535 static PyMethodDef
01536 swigobject_methods[] = {
01537 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
01538 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
01539 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
01540 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
01541 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
01542 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
01543 {0, 0, 0, 0}
01544 };
01545 #else
01546 static PyMethodDef
01547 swigobject_methods[] = {
01548 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
01549 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
01550 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
01551 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
01552 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
01553 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
01554 {0, 0, 0, 0}
01555 };
01556 #endif
01557
01558 #if PY_VERSION_HEX < 0x02020000
01559 SWIGINTERN PyObject *
01560 PySwigObject_getattr(PySwigObject *sobj,char *name)
01561 {
01562 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
01563 }
01564 #endif
01565
01566 SWIGRUNTIME PyTypeObject*
01567 _PySwigObject_type(void) {
01568 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
01569
01570 static PyNumberMethods PySwigObject_as_number = {
01571 (binaryfunc)0,
01572 (binaryfunc)0,
01573 (binaryfunc)0,
01574 (binaryfunc)0,
01575 (binaryfunc)0,
01576 (binaryfunc)0,
01577 (ternaryfunc)0,
01578 (unaryfunc)0,
01579 (unaryfunc)0,
01580 (unaryfunc)0,
01581 (inquiry)0,
01582 0,
01583 0,
01584 0,
01585 0,
01586 0,
01587 0,
01588 (coercion)0,
01589 (unaryfunc)PySwigObject_long,
01590 (unaryfunc)PySwigObject_long,
01591 (unaryfunc)0,
01592 (unaryfunc)PySwigObject_oct,
01593 (unaryfunc)PySwigObject_hex,
01594 #if PY_VERSION_HEX >= 0x02020000
01595 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
01596 #elif PY_VERSION_HEX >= 0x02000000
01597 0,0,0,0,0,0,0,0,0,0,0
01598 #endif
01599 };
01600
01601 static PyTypeObject pyswigobject_type;
01602 static int type_init = 0;
01603 if (!type_init) {
01604 const PyTypeObject tmp
01605 = {
01606 PyObject_HEAD_INIT(NULL)
01607 0,
01608 (char *)"PySwigObject",
01609 sizeof(PySwigObject),
01610 0,
01611 (destructor)PySwigObject_dealloc,
01612 (printfunc)PySwigObject_print,
01613 #if PY_VERSION_HEX < 0x02020000
01614 (getattrfunc)PySwigObject_getattr,
01615 #else
01616 (getattrfunc)0,
01617 #endif
01618 (setattrfunc)0,
01619 (cmpfunc)PySwigObject_compare,
01620 (reprfunc)PySwigObject_repr,
01621 &PySwigObject_as_number,
01622 0,
01623 0,
01624 (hashfunc)0,
01625 (ternaryfunc)0,
01626 (reprfunc)PySwigObject_str,
01627 PyObject_GenericGetAttr,
01628 0,
01629 0,
01630 Py_TPFLAGS_DEFAULT,
01631 swigobject_doc,
01632 0,
01633 0,
01634 0,
01635 0,
01636 #if PY_VERSION_HEX >= 0x02020000
01637 0,
01638 0,
01639 swigobject_methods,
01640 0,
01641 0,
01642 0,
01643 0,
01644 0,
01645 0,
01646 0,
01647 0,
01648 0,
01649 0,
01650 0,
01651 0,
01652 0,
01653 0,
01654 0,
01655 0,
01656 0,
01657 #endif
01658 #if PY_VERSION_HEX >= 0x02030000
01659 0,
01660 #endif
01661 #ifdef COUNT_ALLOCS
01662 0,0,0,0
01663 #endif
01664 };
01665 pyswigobject_type = tmp;
01666 pyswigobject_type.ob_type = &PyType_Type;
01667 type_init = 1;
01668 }
01669 return &pyswigobject_type;
01670 }
01671
01672 SWIGRUNTIME PyObject *
01673 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
01674 {
01675 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
01676 if (sobj) {
01677 sobj->ptr = ptr;
01678 sobj->ty = ty;
01679 sobj->own = own;
01680 sobj->next = 0;
01681 }
01682 return (PyObject *)sobj;
01683 }
01684
01685
01686
01687
01688
01689 typedef struct {
01690 PyObject_HEAD
01691 void *pack;
01692 swig_type_info *ty;
01693 size_t size;
01694 } PySwigPacked;
01695
01696 SWIGRUNTIME int
01697 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
01698 {
01699 char result[SWIG_BUFFER_SIZE];
01700 fputs("<Swig Packed ", fp);
01701 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
01702 fputs("at ", fp);
01703 fputs(result, fp);
01704 }
01705 fputs(v->ty->name,fp);
01706 fputs(">", fp);
01707 return 0;
01708 }
01709
01710 SWIGRUNTIME PyObject *
01711 PySwigPacked_repr(PySwigPacked *v)
01712 {
01713 char result[SWIG_BUFFER_SIZE];
01714 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
01715 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
01716 } else {
01717 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
01718 }
01719 }
01720
01721 SWIGRUNTIME PyObject *
01722 PySwigPacked_str(PySwigPacked *v)
01723 {
01724 char result[SWIG_BUFFER_SIZE];
01725 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
01726 return PyString_FromFormat("%s%s", result, v->ty->name);
01727 } else {
01728 return PyString_FromString(v->ty->name);
01729 }
01730 }
01731
01732 SWIGRUNTIME int
01733 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
01734 {
01735 size_t i = v->size;
01736 size_t j = w->size;
01737 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
01738 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
01739 }
01740
01741 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
01742
01743 SWIGRUNTIME PyTypeObject*
01744 PySwigPacked_type(void) {
01745 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
01746 return type;
01747 }
01748
01749 SWIGRUNTIMEINLINE int
01750 PySwigPacked_Check(PyObject *op) {
01751 return ((op)->ob_type == _PySwigPacked_type())
01752 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
01753 }
01754
01755 SWIGRUNTIME void
01756 PySwigPacked_dealloc(PyObject *v)
01757 {
01758 if (PySwigPacked_Check(v)) {
01759 PySwigPacked *sobj = (PySwigPacked *) v;
01760 free(sobj->pack);
01761 }
01762 PyObject_DEL(v);
01763 }
01764
01765 SWIGRUNTIME PyTypeObject*
01766 _PySwigPacked_type(void) {
01767 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
01768 static PyTypeObject pyswigpacked_type;
01769 static int type_init = 0;
01770 if (!type_init) {
01771 const PyTypeObject tmp
01772 = {
01773 PyObject_HEAD_INIT(NULL)
01774 0,
01775 (char *)"PySwigPacked",
01776 sizeof(PySwigPacked),
01777 0,
01778 (destructor)PySwigPacked_dealloc,
01779 (printfunc)PySwigPacked_print,
01780 (getattrfunc)0,
01781 (setattrfunc)0,
01782 (cmpfunc)PySwigPacked_compare,
01783 (reprfunc)PySwigPacked_repr,
01784 0,
01785 0,
01786 0,
01787 (hashfunc)0,
01788 (ternaryfunc)0,
01789 (reprfunc)PySwigPacked_str,
01790 PyObject_GenericGetAttr,
01791 0,
01792 0,
01793 Py_TPFLAGS_DEFAULT,
01794 swigpacked_doc,
01795 0,
01796 0,
01797 0,
01798 0,
01799 #if PY_VERSION_HEX >= 0x02020000
01800 0,
01801 0,
01802 0,
01803 0,
01804 0,
01805 0,
01806 0,
01807 0,
01808 0,
01809 0,
01810 0,
01811 0,
01812 0,
01813 0,
01814 0,
01815 0,
01816 0,
01817 0,
01818 0,
01819 0,
01820 #endif
01821 #if PY_VERSION_HEX >= 0x02030000
01822 0,
01823 #endif
01824 #ifdef COUNT_ALLOCS
01825 0,0,0,0
01826 #endif
01827 };
01828 pyswigpacked_type = tmp;
01829 pyswigpacked_type.ob_type = &PyType_Type;
01830 type_init = 1;
01831 }
01832 return &pyswigpacked_type;
01833 }
01834
01835 SWIGRUNTIME PyObject *
01836 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
01837 {
01838 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
01839 if (sobj) {
01840 void *pack = malloc(size);
01841 if (pack) {
01842 memcpy(pack, ptr, size);
01843 sobj->pack = pack;
01844 sobj->ty = ty;
01845 sobj->size = size;
01846 } else {
01847 PyObject_DEL((PyObject *) sobj);
01848 sobj = 0;
01849 }
01850 }
01851 return (PyObject *) sobj;
01852 }
01853
01854 SWIGRUNTIME swig_type_info *
01855 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
01856 {
01857 if (PySwigPacked_Check(obj)) {
01858 PySwigPacked *sobj = (PySwigPacked *)obj;
01859 if (sobj->size != size) return 0;
01860 memcpy(ptr, sobj->pack, size);
01861 return sobj->ty;
01862 } else {
01863 return 0;
01864 }
01865 }
01866
01867
01868
01869
01870
01871 SWIGRUNTIMEINLINE PyObject *
01872 _SWIG_This(void)
01873 {
01874 return PyString_FromString("this");
01875 }
01876
01877 SWIGRUNTIME PyObject *
01878 SWIG_This(void)
01879 {
01880 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
01881 return swig_this;
01882 }
01883
01884
01885
01886 SWIGRUNTIME PySwigObject *
01887 SWIG_Python_GetSwigThis(PyObject *pyobj)
01888 {
01889 if (PySwigObject_Check(pyobj)) {
01890 return (PySwigObject *) pyobj;
01891 } else {
01892 PyObject *obj = 0;
01893 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
01894 if (PyInstance_Check(pyobj)) {
01895 obj = _PyInstance_Lookup(pyobj, SWIG_This());
01896 } else {
01897 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
01898 if (dictptr != NULL) {
01899 PyObject *dict = *dictptr;
01900 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
01901 } else {
01902 #ifdef PyWeakref_CheckProxy
01903 if (PyWeakref_CheckProxy(pyobj)) {
01904 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
01905 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
01906 }
01907 #endif
01908 obj = PyObject_GetAttr(pyobj,SWIG_This());
01909 if (obj) {
01910 Py_DECREF(obj);
01911 } else {
01912 if (PyErr_Occurred()) PyErr_Clear();
01913 return 0;
01914 }
01915 }
01916 }
01917 #else
01918 obj = PyObject_GetAttr(pyobj,SWIG_This());
01919 if (obj) {
01920 Py_DECREF(obj);
01921 } else {
01922 if (PyErr_Occurred()) PyErr_Clear();
01923 return 0;
01924 }
01925 #endif
01926 if (obj && !PySwigObject_Check(obj)) {
01927
01928
01929 return SWIG_Python_GetSwigThis(obj);
01930 }
01931 return (PySwigObject *)obj;
01932 }
01933 }
01934
01935
01936
01937 SWIGRUNTIME int
01938 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
01939 if (own) {
01940 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
01941 if (sobj) {
01942 int oldown = sobj->own;
01943 sobj->own = own;
01944 return oldown;
01945 }
01946 }
01947 return 0;
01948 }
01949
01950
01951
01952 SWIGRUNTIME int
01953 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
01954 if (!obj) return SWIG_ERROR;
01955 if (obj == Py_None) {
01956 if (ptr) *ptr = 0;
01957 return SWIG_OK;
01958 } else {
01959 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
01960 while (sobj) {
01961 void *vptr = sobj->ptr;
01962 if (ty) {
01963 swig_type_info *to = sobj->ty;
01964 if (to == ty) {
01965
01966 if (ptr) *ptr = vptr;
01967 break;
01968 } else {
01969 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
01970 if (!tc) {
01971 sobj = (PySwigObject *)sobj->next;
01972 } else {
01973 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
01974 break;
01975 }
01976 }
01977 } else {
01978 if (ptr) *ptr = vptr;
01979 break;
01980 }
01981 }
01982 if (sobj) {
01983 if (own) *own = sobj->own;
01984 if (flags & SWIG_POINTER_DISOWN) {
01985 sobj->own = 0;
01986 }
01987 return SWIG_OK;
01988 } else {
01989 int res = SWIG_ERROR;
01990 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
01991 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
01992 if (data && !data->implicitconv) {
01993 PyObject *klass = data->klass;
01994 if (klass) {
01995 PyObject *impconv;
01996 data->implicitconv = 1;
01997 impconv = SWIG_Python_CallFunctor(klass, obj);
01998 data->implicitconv = 0;
01999 if (PyErr_Occurred()) {
02000 PyErr_Clear();
02001 impconv = 0;
02002 }
02003 if (impconv) {
02004 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
02005 if (iobj) {
02006 void *vptr;
02007 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
02008 if (SWIG_IsOK(res)) {
02009 if (ptr) {
02010 *ptr = vptr;
02011
02012 iobj->own = 0;
02013 res = SWIG_AddCast(res);
02014 res = SWIG_AddNewMask(res);
02015 } else {
02016 res = SWIG_AddCast(res);
02017 }
02018 }
02019 }
02020 Py_DECREF(impconv);
02021 }
02022 }
02023 }
02024 }
02025 return res;
02026 }
02027 }
02028 }
02029
02030
02031
02032 SWIGRUNTIME int
02033 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
02034 if (!PyCFunction_Check(obj)) {
02035 return SWIG_ConvertPtr(obj, ptr, ty, 0);
02036 } else {
02037 void *vptr = 0;
02038
02039
02040 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
02041 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
02042 if (desc) {
02043 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
02044 if (!desc) return SWIG_ERROR;
02045 }
02046 if (ty) {
02047 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
02048 if (!tc) return SWIG_ERROR;
02049 *ptr = SWIG_TypeCast(tc,vptr);
02050 } else {
02051 *ptr = vptr;
02052 }
02053 return SWIG_OK;
02054 }
02055 }
02056
02057
02058
02059 SWIGRUNTIME int
02060 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
02061 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
02062 if (!to) return SWIG_ERROR;
02063 if (ty) {
02064 if (to != ty) {
02065
02066 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
02067 if (!tc) return SWIG_ERROR;
02068 }
02069 }
02070 return SWIG_OK;
02071 }
02072
02073
02074
02075
02076
02077
02078
02079
02080
02081
02082 SWIGRUNTIME PyObject*
02083 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
02084 {
02085 #if (PY_VERSION_HEX >= 0x02020000)
02086 PyObject *inst = 0;
02087 PyObject *newraw = data->newraw;
02088 if (newraw) {
02089 inst = PyObject_Call(newraw, data->newargs, NULL);
02090 if (inst) {
02091 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
02092 PyObject **dictptr = _PyObject_GetDictPtr(inst);
02093 if (dictptr != NULL) {
02094 PyObject *dict = *dictptr;
02095 if (dict == NULL) {
02096 dict = PyDict_New();
02097 *dictptr = dict;
02098 PyDict_SetItem(dict, SWIG_This(), swig_this);
02099 }
02100 }
02101 #else
02102 PyObject *key = SWIG_This();
02103 PyObject_SetAttr(inst, key, swig_this);
02104 #endif
02105 }
02106 } else {
02107 PyObject *dict = PyDict_New();
02108 PyDict_SetItem(dict, SWIG_This(), swig_this);
02109 inst = PyInstance_NewRaw(data->newargs, dict);
02110 Py_DECREF(dict);
02111 }
02112 return inst;
02113 #else
02114 #if (PY_VERSION_HEX >= 0x02010000)
02115 PyObject *inst;
02116 PyObject *dict = PyDict_New();
02117 PyDict_SetItem(dict, SWIG_This(), swig_this);
02118 inst = PyInstance_NewRaw(data->newargs, dict);
02119 Py_DECREF(dict);
02120 return (PyObject *) inst;
02121 #else
02122 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
02123 if (inst == NULL) {
02124 return NULL;
02125 }
02126 inst->in_class = (PyClassObject *)data->newargs;
02127 Py_INCREF(inst->in_class);
02128 inst->in_dict = PyDict_New();
02129 if (inst->in_dict == NULL) {
02130 Py_DECREF(inst);
02131 return NULL;
02132 }
02133 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
02134 inst->in_weakreflist = NULL;
02135 #endif
02136 #ifdef Py_TPFLAGS_GC
02137 PyObject_GC_Init(inst);
02138 #endif
02139 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
02140 return (PyObject *) inst;
02141 #endif
02142 #endif
02143 }
02144
02145 SWIGRUNTIME void
02146 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
02147 {
02148 PyObject *dict;
02149 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
02150 PyObject **dictptr = _PyObject_GetDictPtr(inst);
02151 if (dictptr != NULL) {
02152 dict = *dictptr;
02153 if (dict == NULL) {
02154 dict = PyDict_New();
02155 *dictptr = dict;
02156 }
02157 PyDict_SetItem(dict, SWIG_This(), swig_this);
02158 return;
02159 }
02160 #endif
02161 dict = PyObject_GetAttrString(inst, (char*)"__dict__");
02162 PyDict_SetItem(dict, SWIG_This(), swig_this);
02163 Py_DECREF(dict);
02164 }
02165
02166
02167 SWIGINTERN PyObject *
02168 SWIG_Python_InitShadowInstance(PyObject *args) {
02169 PyObject *obj[2];
02170 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
02171 return NULL;
02172 } else {
02173 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
02174 if (sthis) {
02175 PySwigObject_append((PyObject*) sthis, obj[1]);
02176 } else {
02177 SWIG_Python_SetSwigThis(obj[0], obj[1]);
02178 }
02179 return SWIG_Py_Void();
02180 }
02181 }
02182
02183
02184
02185 SWIGRUNTIME PyObject *
02186 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
02187 if (!ptr) {
02188 return SWIG_Py_Void();
02189 } else {
02190 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
02191 PyObject *robj = PySwigObject_New(ptr, type, own);
02192 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
02193 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
02194 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
02195 if (inst) {
02196 Py_DECREF(robj);
02197 robj = inst;
02198 }
02199 }
02200 return robj;
02201 }
02202 }
02203
02204
02205
02206 SWIGRUNTIMEINLINE PyObject *
02207 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
02208 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
02209 }
02210
02211
02212
02213
02214
02215 #ifdef SWIG_LINK_RUNTIME
02216 void *SWIG_ReturnGlobalTypeList(void *);
02217 #endif
02218
02219 SWIGRUNTIME swig_module_info *
02220 SWIG_Python_GetModule(void) {
02221 static void *type_pointer = (void *)0;
02222
02223 if (!type_pointer) {
02224 #ifdef SWIG_LINK_RUNTIME
02225 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
02226 #else
02227 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
02228 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
02229 if (PyErr_Occurred()) {
02230 PyErr_Clear();
02231 type_pointer = (void *)0;
02232 }
02233 #endif
02234 }
02235 return (swig_module_info *) type_pointer;
02236 }
02237
02238 #if PY_MAJOR_VERSION < 2
02239
02240
02241 SWIGINTERN int
02242 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
02243 {
02244 PyObject *dict;
02245 if (!PyModule_Check(m)) {
02246 PyErr_SetString(PyExc_TypeError,
02247 "PyModule_AddObject() needs module as first arg");
02248 return SWIG_ERROR;
02249 }
02250 if (!o) {
02251 PyErr_SetString(PyExc_TypeError,
02252 "PyModule_AddObject() needs non-NULL value");
02253 return SWIG_ERROR;
02254 }
02255
02256 dict = PyModule_GetDict(m);
02257 if (dict == NULL) {
02258
02259 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
02260 PyModule_GetName(m));
02261 return SWIG_ERROR;
02262 }
02263 if (PyDict_SetItemString(dict, name, o))
02264 return SWIG_ERROR;
02265 Py_DECREF(o);
02266 return SWIG_OK;
02267 }
02268 #endif
02269
02270 SWIGRUNTIME void
02271 SWIG_Python_DestroyModule(void *vptr)
02272 {
02273 swig_module_info *swig_module = (swig_module_info *) vptr;
02274 swig_type_info **types = swig_module->types;
02275 size_t i;
02276 for (i =0; i < swig_module->size; ++i) {
02277 swig_type_info *ty = types[i];
02278 if (ty->owndata) {
02279 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
02280 if (data) PySwigClientData_Del(data);
02281 }
02282 }
02283 Py_DECREF(SWIG_This());
02284 }
02285
02286 SWIGRUNTIME void
02287 SWIG_Python_SetModule(swig_module_info *swig_module) {
02288 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };
02289
02290 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
02291 swig_empty_runtime_method_table);
02292 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
02293 if (pointer && module) {
02294 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
02295 } else {
02296 Py_XDECREF(pointer);
02297 }
02298 }
02299
02300
02301 SWIGRUNTIME PyObject *
02302 SWIG_Python_TypeCache(void) {
02303 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
02304 return cache;
02305 }
02306
02307 SWIGRUNTIME swig_type_info *
02308 SWIG_Python_TypeQuery(const char *type)
02309 {
02310 PyObject *cache = SWIG_Python_TypeCache();
02311 PyObject *key = PyString_FromString(type);
02312 PyObject *obj = PyDict_GetItem(cache, key);
02313 swig_type_info *descriptor;
02314 if (obj) {
02315 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
02316 } else {
02317 swig_module_info *swig_module = SWIG_Python_GetModule();
02318 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
02319 if (descriptor) {
02320 obj = PyCObject_FromVoidPtr(descriptor, NULL);
02321 PyDict_SetItem(cache, key, obj);
02322 Py_DECREF(obj);
02323 }
02324 }
02325 Py_DECREF(key);
02326 return descriptor;
02327 }
02328
02329
02330
02331
02332 #define SWIG_POINTER_EXCEPTION 0
02333 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
02334 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
02335
02336 SWIGRUNTIME int
02337 SWIG_Python_AddErrMesg(const char* mesg, int infront)
02338 {
02339 if (PyErr_Occurred()) {
02340 PyObject *type = 0;
02341 PyObject *value = 0;
02342 PyObject *traceback = 0;
02343 PyErr_Fetch(&type, &value, &traceback);
02344 if (value) {
02345 PyObject *old_str = PyObject_Str(value);
02346 Py_XINCREF(type);
02347 PyErr_Clear();
02348 if (infront) {
02349 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
02350 } else {
02351 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
02352 }
02353 Py_DECREF(old_str);
02354 }
02355 return 1;
02356 } else {
02357 return 0;
02358 }
02359 }
02360
02361 SWIGRUNTIME int
02362 SWIG_Python_ArgFail(int argnum)
02363 {
02364 if (PyErr_Occurred()) {
02365
02366 char mesg[256];
02367 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
02368 return SWIG_Python_AddErrMesg(mesg, 1);
02369 } else {
02370 return 0;
02371 }
02372 }
02373
02374 SWIGRUNTIMEINLINE const char *
02375 PySwigObject_GetDesc(PyObject *self)
02376 {
02377 PySwigObject *v = (PySwigObject *)self;
02378 swig_type_info *ty = v ? v->ty : 0;
02379 return ty ? ty->str : (char*)"";
02380 }
02381
02382 SWIGRUNTIME void
02383 SWIG_Python_TypeError(const char *type, PyObject *obj)
02384 {
02385 if (type) {
02386 #if defined(SWIG_COBJECT_TYPES)
02387 if (obj && PySwigObject_Check(obj)) {
02388 const char *otype = (const char *) PySwigObject_GetDesc(obj);
02389 if (otype) {
02390 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
02391 type, otype);
02392 return;
02393 }
02394 } else
02395 #endif
02396 {
02397 const char *otype = (obj ? obj->ob_type->tp_name : 0);
02398 if (otype) {
02399 PyObject *str = PyObject_Str(obj);
02400 const char *cstr = str ? PyString_AsString(str) : 0;
02401 if (cstr) {
02402 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
02403 type, otype, cstr);
02404 } else {
02405 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
02406 type, otype);
02407 }
02408 Py_XDECREF(str);
02409 return;
02410 }
02411 }
02412 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
02413 } else {
02414 PyErr_Format(PyExc_TypeError, "unexpected type is received");
02415 }
02416 }
02417
02418
02419
02420 SWIGRUNTIME void *
02421 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
02422 void *result;
02423 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
02424 PyErr_Clear();
02425 if (flags & SWIG_POINTER_EXCEPTION) {
02426 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
02427 SWIG_Python_ArgFail(argnum);
02428 }
02429 }
02430 return result;
02431 }
02432
02433
02434 #ifdef __cplusplus
02435 #if 0
02436 {
02437 #endif
02438 }
02439 #endif
02440
02441
02442
02443 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
02444
02445 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
02446
02447
02448
02449
02450
02451 #define SWIGTYPE_p_AtomForce swig_types[0]
02452 #define SWIGTYPE_p_FEMparm swig_types[1]
02453 #define SWIGTYPE_p_MGparm swig_types[2]
02454 #define SWIGTYPE_p_NOsh swig_types[3]
02455 #define SWIGTYPE_p_NOsh_PrintType swig_types[4]
02456 #define SWIGTYPE_p_NOsh_calc swig_types[5]
02457 #define SWIGTYPE_p_PBEparm swig_types[6]
02458 #define SWIGTYPE_p_Vacc swig_types[7]
02459 #define SWIGTYPE_p_Valist swig_types[8]
02460 #define SWIGTYPE_p_Vatom swig_types[9]
02461 #define SWIGTYPE_p_Vcom swig_types[10]
02462 #define SWIGTYPE_p_Vmem swig_types[11]
02463 #define SWIGTYPE_p_Vparam swig_types[12]
02464 #define SWIGTYPE_p_Vpbe swig_types[13]
02465 #define SWIGTYPE_p_Vpmg swig_types[14]
02466 #define SWIGTYPE_p_char swig_types[15]
02467 #define SWIGTYPE_p_double swig_types[16]
02468 #define SWIGTYPE_p_int swig_types[17]
02469 #define SWIGTYPE_p_p_AtomForce swig_types[18]
02470 #define SWIGTYPE_p_p_Valist swig_types[19]
02471 #define SWIGTYPE_p_p_Vgrid swig_types[20]
02472 #define SWIGTYPE_p_p_Vpbe swig_types[21]
02473 #define SWIGTYPE_p_p_Vpmg swig_types[22]
02474 #define SWIGTYPE_p_p_Vpmgp swig_types[23]
02475 static swig_type_info *swig_types[25];
02476 static swig_module_info swig_module = {swig_types, 24, 0, 0, 0, 0};
02477 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
02478 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
02479
02480
02481
02482 #if (PY_VERSION_HEX <= 0x02000000)
02483 # if !defined(SWIG_PYTHON_CLASSIC)
02484 # error "This python version requires swig to be run with the '-classic' option"
02485 # endif
02486 #endif
02487
02488
02489
02490
02491 #define SWIG_init init_apbslib
02492
02493 #define SWIG_name "_apbslib"
02494
02495 #define SWIGVERSION 0x010331
02496 #define SWIG_VERSION SWIGVERSION
02497
02498
02499 #define SWIG_as_voidptr(a) (void *)((const void *)(a))
02500 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a))
02501
02502
02503 #define APBS_SWIG 1
02504 #include "maloc/maloc.h"
02505 #include "apbscfg.h"
02506 #include "routines.h"
02507 #include "apbs/valist.h"
02508 #include "apbs/vatom.h"
02509
02510
02511 #include <limits.h>
02512 #ifndef LLONG_MIN
02513 # define LLONG_MIN LONG_LONG_MIN
02514 #endif
02515 #ifndef LLONG_MAX
02516 # define LLONG_MAX LONG_LONG_MAX
02517 #endif
02518 #ifndef ULLONG_MAX
02519 # define ULLONG_MAX ULONG_LONG_MAX
02520 #endif
02521
02522
02523 SWIGINTERN int
02524 SWIG_AsVal_double (PyObject *obj, double *val)
02525 {
02526 int res = SWIG_TypeError;
02527 if (PyFloat_Check(obj)) {
02528 if (val) *val = PyFloat_AsDouble(obj);
02529 return SWIG_OK;
02530 } else if (PyInt_Check(obj)) {
02531 if (val) *val = PyInt_AsLong(obj);
02532 return SWIG_OK;
02533 } else if (PyLong_Check(obj)) {
02534 double v = PyLong_AsDouble(obj);
02535 if (!PyErr_Occurred()) {
02536 if (val) *val = v;
02537 return SWIG_OK;
02538 } else {
02539 PyErr_Clear();
02540 }
02541 }
02542 #ifdef SWIG_PYTHON_CAST_MODE
02543 {
02544 int dispatch = 0;
02545 double d = PyFloat_AsDouble(obj);
02546 if (!PyErr_Occurred()) {
02547 if (val) *val = d;
02548 return SWIG_AddCast(SWIG_OK);
02549 } else {
02550 PyErr_Clear();
02551 }
02552 if (!dispatch) {
02553 long v = PyLong_AsLong(obj);
02554 if (!PyErr_Occurred()) {
02555 if (val) *val = v;
02556 return SWIG_AddCast(SWIG_AddCast(SWIG_OK));
02557 } else {
02558 PyErr_Clear();
02559 }
02560 }
02561 }
02562 #endif
02563 return res;
02564 }
02565
02566
02567 #include <float.h>
02568
02569
02570 #include <math.h>
02571
02572
02573 SWIGINTERNINLINE int
02574 SWIG_CanCastAsInteger(double *d, double min, double max) {
02575 double x = *d;
02576 if ((min <= x && x <= max)) {
02577 double fx = floor(x);
02578 double cx = ceil(x);
02579 double rd = ((x - fx) < 0.5) ? fx : cx;
02580 if ((errno == EDOM) || (errno == ERANGE)) {
02581 errno = 0;
02582 } else {
02583 double summ, reps, diff;
02584 if (rd < x) {
02585 diff = x - rd;
02586 } else if (rd > x) {
02587 diff = rd - x;
02588 } else {
02589 return 1;
02590 }
02591 summ = rd + x;
02592 reps = diff/summ;
02593 if (reps < 8*DBL_EPSILON) {
02594 *d = rd;
02595 return 1;
02596 }
02597 }
02598 }
02599 return 0;
02600 }
02601
02602
02603 SWIGINTERN int
02604 SWIG_AsVal_long (PyObject *obj, long* val)
02605 {
02606 if (PyInt_Check(obj)) {
02607 if (val) *val = PyInt_AsLong(obj);
02608 return SWIG_OK;
02609 } else if (PyLong_Check(obj)) {
02610 long v = PyLong_AsLong(obj);
02611 if (!PyErr_Occurred()) {
02612 if (val) *val = v;
02613 return SWIG_OK;
02614 } else {
02615 PyErr_Clear();
02616 }
02617 }
02618 #ifdef SWIG_PYTHON_CAST_MODE
02619 {
02620 int dispatch = 0;
02621 long v = PyInt_AsLong(obj);
02622 if (!PyErr_Occurred()) {
02623 if (val) *val = v;
02624 return SWIG_AddCast(SWIG_OK);
02625 } else {
02626 PyErr_Clear();
02627 }
02628 if (!dispatch) {
02629 double d;
02630 int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
02631 if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
02632 if (val) *val = (long)(d);
02633 return res;
02634 }
02635 }
02636 }
02637 #endif
02638 return SWIG_TypeError;
02639 }
02640
02641
02642 SWIGINTERN int
02643 SWIG_AsVal_int (PyObject * obj, int *val)
02644 {
02645 long v;
02646 int res = SWIG_AsVal_long (obj, &v);
02647 if (SWIG_IsOK(res)) {
02648 if ((v < INT_MIN || v > INT_MAX)) {
02649 return SWIG_OverflowError;
02650 } else {
02651 if (val) *val = (int)(v);
02652 }
02653 }
02654 return res;
02655 }
02656
02657
02658 #define SWIG_From_long PyInt_FromLong
02659
02660
02661 SWIGINTERNINLINE PyObject *
02662 SWIG_From_int (int value)
02663 {
02664 return SWIG_From_long (value);
02665 }
02666
02667
02668 #define SWIG_From_double PyFloat_FromDouble
02669
02670
02671 SWIGINTERN swig_type_info*
02672 SWIG_pchar_descriptor(void)
02673 {
02674 static int init = 0;
02675 static swig_type_info* info = 0;
02676 if (!init) {
02677 info = SWIG_TypeQuery("_p_char");
02678 init = 1;
02679 }
02680 return info;
02681 }
02682
02683
02684 SWIGINTERN int
02685 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
02686 {
02687 if (PyString_Check(obj)) {
02688 char *cstr; Py_ssize_t len;
02689 PyString_AsStringAndSize(obj, &cstr, &len);
02690 if (cptr) {
02691 if (alloc) {
02692
02693
02694
02695
02696
02697
02698
02699
02700
02701 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
02702 if (*alloc != SWIG_OLDOBJ)
02703 #else
02704 if (*alloc == SWIG_NEWOBJ)
02705 #endif
02706 {
02707 *cptr = (char *)memcpy((char *)malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1));
02708 *alloc = SWIG_NEWOBJ;
02709 }
02710 else {
02711 *cptr = cstr;
02712 *alloc = SWIG_OLDOBJ;
02713 }
02714 } else {
02715 *cptr = PyString_AsString(obj);
02716 }
02717 }
02718 if (psize) *psize = len + 1;
02719 return SWIG_OK;
02720 } else {
02721 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
02722 if (pchar_descriptor) {
02723 void* vptr = 0;
02724 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
02725 if (cptr) *cptr = (char *) vptr;
02726 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
02727 if (alloc) *alloc = SWIG_OLDOBJ;
02728 return SWIG_OK;
02729 }
02730 }
02731 }
02732 return SWIG_TypeError;
02733 }
02734
02735
02736
02737
02738
02739 SWIGINTERNINLINE PyObject *
02740 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
02741 {
02742 if (carray) {
02743 if (size > INT_MAX) {
02744 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
02745 return pchar_descriptor ?
02746 SWIG_NewPointerObj((char *)(carray), pchar_descriptor, 0) : SWIG_Py_Void();
02747 } else {
02748 return PyString_FromStringAndSize(carray, (int)(size));
02749 }
02750 } else {
02751 return SWIG_Py_Void();
02752 }
02753 }
02754
02755
02756 SWIGINTERNINLINE PyObject *
02757 SWIG_FromCharPtr(const char *cptr)
02758 {
02759 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
02760 }
02761
02762
02763 Valist **new_valist(int maxargs) {
02764 return (Valist **) malloc(maxargs*sizeof(Valist *));
02765 }
02766
02767 Valist *get_Valist(Valist **args, int n){
02768 return (Valist *)args[n];
02769 }
02770
02771 Vgrid **new_gridlist(int maxargs) {
02772 return (Vgrid **) malloc(maxargs*sizeof(Vgrid *));
02773 }
02774
02775 Vpmg **new_pmglist(int maxargs) {
02776 return (Vpmg **) malloc(maxargs*sizeof(Vpmg *));
02777 }
02778
02779 Vpmg *get_Vpmg(Vpmg **args, int n) {
02780 return (Vpmg *)args[n];
02781 }
02782
02783 Vpmgp **new_pmgplist(int maxargs) {
02784 return (Vpmgp **) malloc(maxargs*sizeof(Vpmgp *));
02785 }
02786
02787 Vpbe **new_pbelist(int maxargs) {
02788 return (Vpbe **) malloc(maxargs*sizeof(Vpbe *));
02789 }
02790
02791 Vpbe *get_Vpbe(Vpbe **args, int n) {
02792 return (Vpbe *)args[n];
02793 }
02794
02795 AtomForce **new_atomforcelist(int maxargs) {
02796 return (AtomForce **) malloc(maxargs*sizeof(AtomForce *));
02797 }
02798
02799 void delete_atomforcelist(AtomForce **a) {
02800 free(a);
02801 }
02802 void delete_valist(Valist **a) {
02803 free(a);
02804 }
02805 void delete_gridlist(Vgrid **a) {
02806 free(a);
02807 }
02808 void delete_pmglist(Vpmg **a) {
02809 free(a);
02810 }
02811 void delete_pmgplist(Vpmgp **a) {
02812 free(a);
02813 }
02814 void delete_pbelist(Vpbe **a) {
02815 free(a);
02816 }
02817
02818 void delete_Nosh(NOsh *nosh) {
02819 NOsh_dtor(&nosh);
02820 }
02821
02822 void delete_Com(Vcom *com) {
02823 Vcom_dtor(&com);
02824 }
02825
02826 void delete_Mem(Vmem *mem) {
02827 Vmem_dtor(&mem);
02828 }
02829
02830 AtomForce **get_AtomForce(AtomForce **aforce, int n){
02831 return &aforce[n];
02832 }
02833
02834 Valist *make_Valist(Valist **args, int n){
02835 args[n] = Valist_ctor();
02836 return args[n];
02837 }
02838
02839 void remove_Valist(Valist *thee){
02840 Valist_dtor2(thee);
02841 }
02842
02843
02844
02845
02846
02847 double *double_array(int size) {
02848 return (double *) malloc(size*sizeof(double));
02849 }
02850
02851 int *int_array(int size){
02852 return (int *) malloc(size*sizeof(int));
02853 }
02854
02855 void delete_double_array(double *d) {
02856 free(d);
02857 }
02858
02859 void delete_int_array(int *i) {
02860 free(i);
02861 }
02862
02863 double get_entry(double *array, int i){
02864 return array[i];
02865 }
02866
02867 void set_entry(double *array, int i, double val){
02868 array[i] = val;
02869 }
02870
02871
02872
02873 int parseInputFromString(NOsh *nosh, PyObject *string){
02874
02875 int ret, bufsize;
02876 Vio *sock;
02877
02878 startVio();
02879 bufsize = PyString_Size(string);
02880
02881 VASSERT( bufsize <= VMAX_BUFSIZE );
02882 sock = Vio_ctor("BUFF","ASC",VNULL,"0","r");
02883
02884 Vio_bufTake(sock, PyString_AsString(string), bufsize);
02885
02886 ret = NOsh_parseInput(nosh, sock);
02887 sock->VIObuffer = VNULL;
02888 Vio_dtor(&sock);
02889 return ret;
02890 }
02891
02892 void Valist_load(Valist *thee, int size, PyObject *x, PyObject *y, PyObject *z, PyObject *chg, PyObject *rad){
02893
02894 int i,j;
02895 double pos[3];
02896
02897 Vatom *atom;
02898
02899 VASSERT(thee != VNULL);
02900
02901 thee->atoms = Vmem_malloc(thee->vmem, size, sizeof(Vatom));
02902 thee->number = size;
02903 for (i=0;i<size;i++){
02904 pos[0] = PyFloat_AsDouble(PyList_GetItem(x,i));
02905 pos[1] = PyFloat_AsDouble(PyList_GetItem(y,i));
02906 pos[2] = PyFloat_AsDouble(PyList_GetItem(z,i));
02907 Vatom_setCharge(&(thee->atoms[i]), PyFloat_AsDouble(PyList_GetItem(chg,i)));
02908 Vatom_setRadius(&(thee->atoms[i]), PyFloat_AsDouble(PyList_GetItem(rad,i)));
02909 Vatom_setPosition(&(thee->atoms[i]), pos);
02910 Vatom_setAtomID(&(thee->atoms[i]), i);
02911 }
02912
02913 thee->center[0] = 0.0;
02914 thee->center[1] = 0.0;
02915 thee->center[2] = 0.0;
02916 thee->maxrad = 0.0;
02917 thee->charge = 0.0;
02918
02919
02920 atom = &(thee->atoms[0]);
02921 for (i=0; i<3; i++) {
02922 thee->maxcrd[i] = thee->mincrd[i] = atom->position[i];
02923 }
02924 thee->maxrad = atom->radius;
02925
02926 for (i=0; i<thee->number; i++) {
02927 atom = &(thee->atoms[i]);
02928 for (j=0; j<3; j++) {
02929 if (atom->position[j] < thee->mincrd[j])
02930 thee->mincrd[j] = atom->position[j];
02931 if (atom->position[j] > thee->maxcrd[j])
02932 thee->maxcrd[j] = atom->position[j];
02933 }
02934 if (atom->radius > thee->maxrad) thee->maxrad = atom->radius;
02935 thee->charge = thee->charge + atom->charge;
02936 }
02937
02938 thee->center[0] = 0.5*(thee->maxcrd[0] + thee->mincrd[0]);
02939 thee->center[1] = 0.5*(thee->maxcrd[1] + thee->mincrd[1]);
02940 thee->center[2] = 0.5*(thee->maxcrd[2] + thee->mincrd[2]);
02941
02942 }
02943
02944 extern int NOsh_setupElecCalc(NOsh *nosh, Valist *alist[NOSH_MAXMOL]);
02945 extern int NOsh_setupApolCalc(NOsh *nosh, Valist *alist[NOSH_MAXMOL]);
02946
02947 int wrap_forceMG(Vmem *mem, NOsh *nosh, PBEparm *pbeparm, MGparm *mgparm,
02948 Vpmg *pmg, AtomForce *atomForce[NOSH_MAXCALC], Valist *alist[NOSH_MAXMOL],
02949 int forcearray[NOSH_MAXCALC], int calcid)
02950 {
02951 int *nforce;
02952 nforce = malloc(sizeof(int));
02953 *nforce = 0;
02954 forceMG(mem, nosh, pbeparm, mgparm, pmg, nforce, atomForce, alist);
02955 forcearray[calcid] = *nforce;
02956
02957 return *nforce;
02958 }
02959
02960 PyObject *getAtomPosition(Vatom *atom){
02961 double *position;
02962 int i;
02963 PyObject *values;
02964
02965 values = PyList_New(3);
02966 for (i=0; i<3; i++){
02967 position = Vatom_getPosition(atom);
02968 PyList_SetItem(values, i, PyFloat_FromDouble(position[i]));
02969 }
02970
02971 return values;
02972 }
02973
02974 PyObject *getPotentials(NOsh *nosh, PBEparm *pbeparm, Vpmg *pmg, Valist *alist){
02975 Vgrid *grid;
02976 Vatom *atom;
02977 int i, rc, nx, ny, nz;
02978 double hx, hy, hzed, xcent, ycent, zcent, xmin, ymin, zmin;
02979 double value;
02980 double *position;
02981 PyObject *values;
02982
02983 values = PyList_New(Valist_getNumberAtoms(alist));
02984 nx = pmg->pmgp->nx;
02985 ny = pmg->pmgp->ny;
02986 nz = pmg->pmgp->nz;
02987 hx = pmg->pmgp->hx;
02988 hy = pmg->pmgp->hy;
02989 hzed = pmg->pmgp->hzed;
02990 xcent = pmg->pmgp->xcent;
02991 ycent = pmg->pmgp->ycent;
02992 zcent = pmg->pmgp->zcent;
02993 xmin = xcent - 0.5*(nx-1)*hx;
02994 ymin = ycent - 0.5*(ny-1)*hy;
02995 zmin = zcent - 0.5*(nz-1)*hzed;
02996
02997 Vpmg_fillArray(pmg, pmg->rwork, VDT_POT, 0.0, pbeparm->pbetype, pbeparm);
02998 grid = Vgrid_ctor(nx, ny, nz, hx, hy, hzed, xmin, ymin, zmin,
02999 pmg->rwork);
03000 for (i=0;i<Valist_getNumberAtoms(alist);i++){
03001 atom = Valist_getAtom(alist, i);
03002 position = Vatom_getPosition(atom);
03003 Vgrid_value(grid, position, &value);
03004 PyList_SetItem(values, i, PyFloat_FromDouble(value));
03005 }
03006 Vgrid_dtor(&grid);
03007 return values;
03008 }
03009
03010 PyObject *getEnergies(Vpmg *pmg, Valist *alist){
03011 Vatom *atom;
03012 int i;
03013 double energy;
03014 PyObject *values;
03015
03016 values = PyList_New(Valist_getNumberAtoms(alist));
03017 for (i=0;i<Valist_getNumberAtoms(alist);i++){
03018 atom = Valist_getAtom(alist, i);
03019 energy = Vpmg_qfAtomEnergy(pmg, atom);
03020 PyList_SetItem(values, i, PyFloat_FromDouble(energy));
03021 }
03022 return values;
03023 }
03024
03025 PyObject *getForces(AtomForce **atomForce, Valist *alist){
03026 int i, j;
03027 PyObject *dict;
03028 PyObject *qfvalues, *qf, *qfholder;
03029 PyObject *ibvalues, *ib, *ibholder;
03030 PyObject *dbvalues, *db, *dbholder;
03031 PyObject *npvalues, *np, *npholder;
03032
03033 dict = PyDict_New();
03034 qfvalues = PyList_New(Valist_getNumberAtoms(alist));
03035 dbvalues = PyList_New(Valist_getNumberAtoms(alist));
03036 ibvalues = PyList_New(Valist_getNumberAtoms(alist));
03037
03038 qfholder = PyList_New(3);
03039 dbholder = PyList_New(3);
03040 ibholder = PyList_New(3);
03041
03042 qf = PyString_FromString("qf");
03043 db = PyString_FromString("db");
03044 ib = PyString_FromString("ib");
03045
03046 for (i=0;i<Valist_getNumberAtoms(alist);i++){
03047 for (j=0;j<3;j++){
03048 PyList_SetItem(qfholder, j, PyFloat_FromDouble(atomForce[0][i].qfForce[j]));
03049 PyList_SetItem(dbholder, j, PyFloat_FromDouble(atomForce[0][i].dbForce[j]));
03050 PyList_SetItem(ibholder, j, PyFloat_FromDouble(atomForce[0][i].ibForce[j]));
03051 }
03052 PyList_SetItem(qfvalues, i, PyList_GetSlice(qfholder, 0, 3));
03053 PyList_SetItem(dbvalues, i, PyList_GetSlice(dbholder, 0, 3));
03054 PyList_SetItem(ibvalues, i, PyList_GetSlice(ibholder, 0, 3));
03055 }
03056 PyDict_SetItem(dict, qf, qfvalues);
03057 PyDict_SetItem(dict, db, dbvalues);
03058 PyDict_SetItem(dict, ib, ibvalues);
03059 return dict;
03060 }
03061
03062 #ifdef __cplusplus
03063 extern "C" {
03064 #endif
03065 SWIGINTERN PyObject *_wrap_new_Valist(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03066 PyObject *resultobj = 0;
03067 Valist *result = 0 ;
03068
03069 if (!PyArg_ParseTuple(args,(char *)":new_Valist")) SWIG_fail;
03070 result = (Valist *)(Valist *) calloc(1, sizeof(Valist));
03071 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Valist, SWIG_POINTER_NEW | 0 );
03072 return resultobj;
03073 fail:
03074 return NULL;
03075 }
03076
03077
03078 SWIGINTERN PyObject *_wrap_delete_Valist(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03079 PyObject *resultobj = 0;
03080 Valist *arg1 = (Valist *) 0 ;
03081 void *argp1 = 0 ;
03082 int res1 = 0 ;
03083 PyObject * obj0 = 0 ;
03084
03085 if (!PyArg_ParseTuple(args,(char *)"O:delete_Valist",&obj0)) SWIG_fail;
03086 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Valist, SWIG_POINTER_DISOWN | 0 );
03087 if (!SWIG_IsOK(res1)) {
03088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Valist" "', argument " "1"" of type '" "Valist *""'");
03089 }
03090 arg1 = (Valist *)(argp1);
03091 free((char *) arg1);
03092
03093 resultobj = SWIG_Py_Void();
03094 return resultobj;
03095 fail:
03096 return NULL;
03097 }
03098
03099
03100 SWIGINTERN PyObject *_wrap_Valist_number_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03101 PyObject *resultobj = 0;
03102 Valist *arg1 = (Valist *) 0 ;
03103 int arg2 ;
03104 void *argp1 = 0 ;
03105 int res1 = 0 ;
03106 int val2 ;
03107 int ecode2 = 0 ;
03108 PyObject * obj0 = 0 ;
03109 PyObject * obj1 = 0 ;
03110
03111 if (!PyArg_ParseTuple(args,(char *)"OO:Valist_number_set",&obj0,&obj1)) SWIG_fail;
03112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Valist, 0 | 0 );
03113 if (!SWIG_IsOK(res1)) {
03114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Valist_number_set" "', argument " "1"" of type '" "Valist *""'");
03115 }
03116 arg1 = (Valist *)(argp1);
03117 ecode2 = SWIG_AsVal_int(obj1, &val2);
03118 if (!SWIG_IsOK(ecode2)) {
03119 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Valist_number_set" "', argument " "2"" of type '" "int""'");
03120 }
03121 arg2 = (int)(val2);
03122 if (arg1) (arg1)->number = arg2;
03123
03124 resultobj = SWIG_Py_Void();
03125 return resultobj;
03126 fail:
03127 return NULL;
03128 }
03129
03130
03131 SWIGINTERN PyObject *_wrap_Valist_number_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03132 PyObject *resultobj = 0;
03133 Valist *arg1 = (Valist *) 0 ;
03134 int result;
03135 void *argp1 = 0 ;
03136 int res1 = 0 ;
03137 PyObject * obj0 = 0 ;
03138
03139 if (!PyArg_ParseTuple(args,(char *)"O:Valist_number_get",&obj0)) SWIG_fail;
03140 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Valist, 0 | 0 );
03141 if (!SWIG_IsOK(res1)) {
03142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Valist_number_get" "', argument " "1"" of type '" "Valist *""'");
03143 }
03144 arg1 = (Valist *)(argp1);
03145 result = (int) ((arg1)->number);
03146 resultobj = SWIG_From_int((int)(result));
03147 return resultobj;
03148 fail:
03149 return NULL;
03150 }
03151
03152
03153 SWIGINTERN PyObject *Valist_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03154 PyObject *obj;
03155 if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
03156 SWIG_TypeNewClientData(SWIGTYPE_p_Valist, SWIG_NewClientData(obj));
03157 return SWIG_Py_Void();
03158 }
03159
03160 SWIGINTERN PyObject *_wrap_Valist_getAtomList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03161 PyObject *resultobj = 0;
03162 Valist *arg1 = (Valist *) 0 ;
03163 Vatom *result = 0 ;
03164 void *argp1 = 0 ;
03165 int res1 = 0 ;
03166 PyObject * obj0 = 0 ;
03167
03168 if (!PyArg_ParseTuple(args,(char *)"O:Valist_getAtomList",&obj0)) SWIG_fail;
03169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Valist, 0 | 0 );
03170 if (!SWIG_IsOK(res1)) {
03171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Valist_getAtomList" "', argument " "1"" of type '" "Valist *""'");
03172 }
03173 arg1 = (Valist *)(argp1);
03174 result = (Vatom *)Valist_getAtomList(arg1);
03175 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Vatom, 0 | 0 );
03176 return resultobj;
03177 fail:
03178 return NULL;
03179 }
03180
03181
03182 SWIGINTERN PyObject *_wrap_Valist_getAtom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03183 PyObject *resultobj = 0;
03184 Valist *arg1 = (Valist *) 0 ;
03185 int arg2 ;
03186 Vatom *result = 0 ;
03187 void *argp1 = 0 ;
03188 int res1 = 0 ;
03189 int val2 ;
03190 int ecode2 = 0 ;
03191 PyObject * obj0 = 0 ;
03192 PyObject * obj1 = 0 ;
03193
03194 if (!PyArg_ParseTuple(args,(char *)"OO:Valist_getAtom",&obj0,&obj1)) SWIG_fail;
03195 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Valist, 0 | 0 );
03196 if (!SWIG_IsOK(res1)) {
03197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Valist_getAtom" "', argument " "1"" of type '" "Valist *""'");
03198 }
03199 arg1 = (Valist *)(argp1);
03200 ecode2 = SWIG_AsVal_int(obj1, &val2);
03201 if (!SWIG_IsOK(ecode2)) {
03202 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Valist_getAtom" "', argument " "2"" of type '" "int""'");
03203 }
03204 arg2 = (int)(val2);
03205 result = (Vatom *)Valist_getAtom(arg1,arg2);
03206 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Vatom, 0 | 0 );
03207 return resultobj;
03208 fail:
03209 return NULL;
03210 }
03211
03212
03213 SWIGINTERN PyObject *_wrap_new_Vatom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03214 PyObject *resultobj = 0;
03215 Vatom *result = 0 ;
03216
03217 if (!PyArg_ParseTuple(args,(char *)":new_Vatom")) SWIG_fail;
03218 result = (Vatom *)(Vatom *) calloc(1, sizeof(Vatom));
03219 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Vatom, SWIG_POINTER_NEW | 0 );
03220 return resultobj;
03221 fail:
03222 return NULL;
03223 }
03224
03225
03226 SWIGINTERN PyObject *_wrap_delete_Vatom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03227 PyObject *resultobj = 0;
03228 Vatom *arg1 = (Vatom *) 0 ;
03229 void *argp1 = 0 ;
03230 int res1 = 0 ;
03231 PyObject * obj0 = 0 ;
03232
03233 if (!PyArg_ParseTuple(args,(char *)"O:delete_Vatom",&obj0)) SWIG_fail;
03234 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Vatom, SWIG_POINTER_DISOWN | 0 );
03235 if (!SWIG_IsOK(res1)) {
03236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Vatom" "', argument " "1"" of type '" "Vatom *""'");
03237 }
03238 arg1 = (Vatom *)(argp1);
03239 free((char *) arg1);
03240
03241 resultobj = SWIG_Py_Void();
03242 return resultobj;
03243 fail:
03244 return NULL;
03245 }
03246
03247
03248 SWIGINTERN PyObject *_wrap_Vatom_id_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03249 PyObject *resultobj = 0;
03250 Vatom *arg1 = (Vatom *) 0 ;
03251 int arg2 ;
03252 void *argp1 = 0 ;
03253 int res1 = 0 ;
03254 int val2 ;
03255 int ecode2 = 0 ;
03256 PyObject * obj0 = 0 ;
03257 PyObject * obj1 = 0 ;
03258
03259 if (!PyArg_ParseTuple(args,(char *)"OO:Vatom_id_set",&obj0,&obj1)) SWIG_fail;
03260 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Vatom, 0 | 0 );
03261 if (!SWIG_IsOK(res1)) {
03262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vatom_id_set" "', argument " "1"" of type '" "Vatom *""'");
03263 }
03264 arg1 = (Vatom *)(argp1);
03265 ecode2 = SWIG_AsVal_int(obj1, &val2);
03266 if (!SWIG_IsOK(ecode2)) {
03267 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vatom_id_set" "', argument " "2"" of type '" "int""'");
03268 }
03269 arg2 = (int)(val2);
03270 if (arg1) (arg1)->id = arg2;
03271
03272 resultobj = SWIG_Py_Void();
03273 return resultobj;
03274 fail:
03275 return NULL;
03276 }
03277
03278
03279 SWIGINTERN PyObject *_wrap_Vatom_id_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03280 PyObject *resultobj = 0;
03281 Vatom *arg1 = (Vatom *) 0 ;
03282 int result;
03283 void *argp1 = 0 ;
03284 int res1 = 0 ;
03285 PyObject * obj0 = 0 ;
03286
03287 if (!PyArg_ParseTuple(args,(char *)"O:Vatom_id_get",&obj0)) SWIG_fail;
03288 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Vatom, 0 | 0 );
03289 if (!SWIG_IsOK(res1)) {
03290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vatom_id_get" "', argument " "1"" of type '" "Vatom *""'");
03291 }
03292 arg1 = (Vatom *)(argp1);
03293 result = (int) ((arg1)->id);
03294 resultobj = SWIG_From_int((int)(result));
03295 return resultobj;
03296 fail:
03297 return NULL;
03298 }
03299
03300
03301 SWIGINTERN PyObject *Vatom_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03302 PyObject *obj;
03303 if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
03304 SWIG_TypeNewClientData(SWIGTYPE_p_Vatom, SWIG_NewClientData(obj));
03305 return SWIG_Py_Void();
03306 }
03307
03308 SWIGINTERN PyObject *_wrap_Vatom_getPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03309 PyObject *resultobj = 0;
03310 Vatom *arg1 = (Vatom *) 0 ;
03311 double *result = 0 ;
03312 void *argp1 = 0 ;
03313 int res1 = 0 ;
03314 PyObject * obj0 = 0 ;
03315
03316 if (!PyArg_ParseTuple(args,(char *)"O:Vatom_getPosition",&obj0)) SWIG_fail;
03317 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Vatom, 0 | 0 );
03318 if (!SWIG_IsOK(res1)) {
03319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vatom_getPosition" "', argument " "1"" of type '" "Vatom *""'");
03320 }
03321 arg1 = (Vatom *)(argp1);
03322 result = (double *)Vatom_getPosition(arg1);
03323 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 );
03324 return resultobj;
03325 fail:
03326 return NULL;
03327 }
03328
03329
03330 SWIGINTERN PyObject *_wrap_Vatom_setCharge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03331 PyObject *resultobj = 0;
03332 Vatom *arg1 = (Vatom *) 0 ;
03333 double arg2 ;
03334 void *argp1 = 0 ;
03335 int res1 = 0 ;
03336 double val2 ;
03337 int ecode2 = 0 ;
03338 PyObject * obj0 = 0 ;
03339 PyObject * obj1 = 0 ;
03340
03341 if (!PyArg_ParseTuple(args,(char *)"OO:Vatom_setCharge",&obj0,&obj1)) SWIG_fail;
03342 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Vatom, 0 | 0 );
03343 if (!SWIG_IsOK(res1)) {
03344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vatom_setCharge" "', argument " "1"" of type '" "Vatom *""'");
03345 }
03346 arg1 = (Vatom *)(argp1);
03347 ecode2 = SWIG_AsVal_double(obj1, &val2);
03348 if (!SWIG_IsOK(ecode2)) {
03349 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vatom_setCharge" "', argument " "2"" of type '" "double""'");
03350 }
03351 arg2 = (double)(val2);
03352 Vatom_setCharge(arg1,arg2);
03353 resultobj = SWIG_Py_Void();
03354 return resultobj;
03355 fail:
03356 return NULL;
03357 }
03358
03359
03360 SWIGINTERN PyObject *_wrap_Vatom_getCharge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03361 PyObject *resultobj = 0;
03362 Vatom *arg1 = (Vatom *) 0 ;
03363 double result;
03364 void *argp1 = 0 ;
03365 int res1 = 0 ;
03366 PyObject * obj0 = 0 ;
03367
03368 if (!PyArg_ParseTuple(args,(char *)"O:Vatom_getCharge",&obj0)) SWIG_fail;
03369 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Vatom, 0 | 0 );
03370 if (!SWIG_IsOK(res1)) {
03371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vatom_getCharge" "', argument " "1"" of type '" "Vatom *""'");
03372 }
03373 arg1 = (Vatom *)(argp1);
03374 result = (double)Vatom_getCharge(arg1);
03375 resultobj = SWIG_From_double((double)(result));
03376 return resultobj;
03377 fail:
03378 return NULL;
03379 }
03380
03381
03382 SWIGINTERN PyObject *_wrap_Vatom_getRadius(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03383 PyObject *resultobj = 0;
03384 Vatom *arg1 = (Vatom *) 0 ;
03385 double result;
03386 void *argp1 = 0 ;
03387 int res1 = 0 ;
03388 PyObject * obj0 = 0 ;
03389
03390 if (!PyArg_ParseTuple(args,(char *)"O:Vatom_getRadius",&obj0)) SWIG_fail;
03391 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Vatom, 0 | 0 );
03392 if (!SWIG_IsOK(res1)) {
03393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vatom_getRadius" "', argument " "1"" of type '" "Vatom *""'");
03394 }
03395 arg1 = (Vatom *)(argp1);
03396 result = (double)Vatom_getRadius(arg1);
03397 resultobj = SWIG_From_double((double)(result));
03398 return resultobj;
03399 fail:
03400 return NULL;
03401 }
03402
03403
03404 SWIGINTERN PyObject *_wrap_new_MGparm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03405 PyObject *resultobj = 0;
03406 MGparm *result = 0 ;
03407
03408 if (!PyArg_ParseTuple(args,(char *)":new_MGparm")) SWIG_fail;
03409 result = (MGparm *)(MGparm *) calloc(1, sizeof(MGparm));
03410 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MGparm, SWIG_POINTER_NEW | 0 );
03411 return resultobj;
03412 fail:
03413 return NULL;
03414 }
03415
03416
03417 SWIGINTERN PyObject *_wrap_delete_MGparm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03418 PyObject *resultobj = 0;
03419 MGparm *arg1 = (MGparm *) 0 ;
03420 void *argp1 = 0 ;
03421 int res1 = 0 ;
03422 PyObject * obj0 = 0 ;
03423
03424 if (!PyArg_ParseTuple(args,(char *)"O:delete_MGparm",&obj0)) SWIG_fail;
03425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_MGparm, SWIG_POINTER_DISOWN | 0 );
03426 if (!SWIG_IsOK(res1)) {
03427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MGparm" "', argument " "1"" of type '" "MGparm *""'");
03428 }
03429 arg1 = (MGparm *)(argp1);
03430 free((char *) arg1);
03431
03432 resultobj = SWIG_Py_Void();
03433 return resultobj;
03434 fail:
03435 return NULL;
03436 }
03437
03438
03439 SWIGINTERN PyObject *_wrap_MGparm_type_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03440 PyObject *resultobj = 0;
03441 MGparm *arg1 = (MGparm *) 0 ;
03442 MGparm_CalcType arg2 ;
03443 void *argp1 = 0 ;
03444 int res1 = 0 ;
03445 int val2 ;
03446 int ecode2 = 0 ;
03447 PyObject * obj0 = 0 ;
03448 PyObject * obj1 = 0 ;
03449
03450 if (!PyArg_ParseTuple(args,(char *)"OO:MGparm_type_set",&obj0,&obj1)) SWIG_fail;
03451 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_MGparm, 0 | 0 );
03452 if (!SWIG_IsOK(res1)) {
03453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MGparm_type_set" "', argument " "1"" of type '" "MGparm *""'");
03454 }
03455 arg1 = (MGparm *)(argp1);
03456 ecode2 = SWIG_AsVal_int(obj1, &val2);
03457 if (!SWIG_IsOK(ecode2)) {
03458 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MGparm_type_set" "', argument " "2"" of type '" "MGparm_CalcType""'");
03459 }
03460 arg2 = (MGparm_CalcType)(val2);
03461 if (arg1) (arg1)->type = arg2;
03462
03463 resultobj = SWIG_Py_Void();
03464 return resultobj;
03465 fail:
03466 return NULL;
03467 }
03468
03469
03470 SWIGINTERN PyObject *_wrap_MGparm_type_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03471 PyObject *resultobj = 0;
03472 MGparm *arg1 = (MGparm *) 0 ;
03473 MGparm_CalcType result;
03474 void *argp1 = 0 ;
03475 int res1 = 0 ;
03476 PyObject * obj0 = 0 ;
03477
03478 if (!PyArg_ParseTuple(args,(char *)"O:MGparm_type_get",&obj0)) SWIG_fail;
03479 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_MGparm, 0 | 0 );
03480 if (!SWIG_IsOK(res1)) {
03481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MGparm_type_get" "', argument " "1"" of type '" "MGparm *""'");
03482 }
03483 arg1 = (MGparm *)(argp1);
03484 result = (MGparm_CalcType) ((arg1)->type);
03485 resultobj = SWIG_From_int((int)(result));
03486 return resultobj;
03487 fail:
03488 return NULL;
03489 }
03490
03491
03492 SWIGINTERN PyObject *MGparm_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03493 PyObject *obj;
03494 if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
03495 SWIG_TypeNewClientData(SWIGTYPE_p_MGparm, SWIG_NewClientData(obj));
03496 return SWIG_Py_Void();
03497 }
03498
03499 SWIGINTERN PyObject *_wrap_MGparm_setCenterX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03500 PyObject *resultobj = 0;
03501 MGparm *arg1 = (MGparm *) 0 ;
03502 double arg2 ;
03503 void *argp1 = 0 ;
03504 int res1 = 0 ;
03505 double val2 ;
03506 int ecode2 = 0 ;
03507 PyObject * obj0 = 0 ;
03508 PyObject * obj1 = 0 ;
03509
03510 if (!PyArg_ParseTuple(args,(char *)"OO:MGparm_setCenterX",&obj0,&obj1)) SWIG_fail;
03511 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_MGparm, 0 | 0 );
03512 if (!SWIG_IsOK(res1)) {
03513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MGparm_setCenterX" "', argument " "1"" of type '" "MGparm *""'");
03514 }
03515 arg1 = (MGparm *)(argp1);
03516 ecode2 = SWIG_AsVal_double(obj1, &val2);
03517 if (!SWIG_IsOK(ecode2)) {
03518 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MGparm_setCenterX" "', argument " "2"" of type '" "double""'");
03519 }
03520 arg2 = (double)(val2);
03521 MGparm_setCenterX(arg1,arg2);
03522 resultobj = SWIG_Py_Void();
03523 return resultobj;
03524 fail:
03525 return NULL;
03526 }
03527
03528
03529 SWIGINTERN PyObject *_wrap_MGparm_setCenterY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03530 PyObject *resultobj = 0;
03531 MGparm *arg1 = (MGparm *) 0 ;
03532 double arg2 ;
03533 void *argp1 = 0 ;
03534 int res1 = 0 ;
03535 double val2 ;
03536 int ecode2 = 0 ;
03537 PyObject * obj0 = 0 ;
03538 PyObject * obj1 = 0 ;
03539
03540 if (!PyArg_ParseTuple(args,(char *)"OO:MGparm_setCenterY",&obj0,&obj1)) SWIG_fail;
03541 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_MGparm, 0 | 0 );
03542 if (!SWIG_IsOK(res1)) {
03543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MGparm_setCenterY" "', argument " "1"" of type '" "MGparm *""'");
03544 }
03545 arg1 = (MGparm *)(argp1);
03546 ecode2 = SWIG_AsVal_double(obj1, &val2);
03547 if (!SWIG_IsOK(ecode2)) {
03548 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MGparm_setCenterY" "', argument " "2"" of type '" "double""'");
03549 }
03550 arg2 = (double)(val2);
03551 MGparm_setCenterY(arg1,arg2);
03552 resultobj = SWIG_Py_Void();
03553 return resultobj;
03554 fail:
03555 return NULL;
03556 }
03557
03558
03559 SWIGINTERN PyObject *_wrap_MGparm_setCenterZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03560 PyObject *resultobj = 0;
03561 MGparm *arg1 = (MGparm *) 0 ;
03562 double arg2 ;
03563 void *argp1 = 0 ;
03564 int res1 = 0 ;
03565 double val2 ;
03566 int ecode2 = 0 ;
03567 PyObject * obj0 = 0 ;
03568 PyObject * obj1 = 0 ;
03569
03570 if (!PyArg_ParseTuple(args,(char *)"OO:MGparm_setCenterZ",&obj0,&obj1)) SWIG_fail;
03571 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_MGparm, 0 | 0 );
03572 if (!SWIG_IsOK(res1)) {
03573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MGparm_setCenterZ" "', argument " "1"" of type '" "MGparm *""'");
03574 }
03575 arg1 = (MGparm *)(argp1);
03576 ecode2 = SWIG_AsVal_double(obj1, &val2);
03577 if (!SWIG_IsOK(ecode2)) {
03578 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MGparm_setCenterZ" "', argument " "2"" of type '" "double""'");
03579 }
03580 arg2 = (double)(val2);
03581 MGparm_setCenterZ(arg1,arg2);
03582 resultobj = SWIG_Py_Void();
03583 return resultobj;
03584 fail:
03585 return NULL;
03586 }
03587
03588
03589 SWIGINTERN PyObject *_wrap_new_PBEparm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03590 PyObject *resultobj = 0;
03591 PBEparm *result = 0 ;
03592
03593 if (!PyArg_ParseTuple(args,(char *)":new_PBEparm")) SWIG_fail;
03594 result = (PBEparm *)(PBEparm *) calloc(1, sizeof(PBEparm));
03595 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_PBEparm, SWIG_POINTER_NEW | 0 );
03596 return resultobj;
03597 fail:
03598 return NULL;
03599 }
03600
03601
03602 SWIGINTERN PyObject *_wrap_delete_PBEparm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03603 PyObject *resultobj = 0;
03604 PBEparm *arg1 = (PBEparm *) 0 ;
03605 void *argp1 = 0 ;
03606 int res1 = 0 ;
03607 PyObject * obj0 = 0 ;
03608
03609 if (!PyArg_ParseTuple(args,(char *)"O:delete_PBEparm",&obj0)) SWIG_fail;
03610 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PBEparm, SWIG_POINTER_DISOWN | 0 );
03611 if (!SWIG_IsOK(res1)) {
03612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PBEparm" "', argument " "1"" of type '" "PBEparm *""'");
03613 }
03614 arg1 = (PBEparm *)(argp1);
03615 free((char *) arg1);
03616
03617 resultobj = SWIG_Py_Void();
03618 return resultobj;
03619 fail:
03620 return NULL;
03621 }
03622
03623
03624 SWIGINTERN PyObject *_wrap_PBEparm_temp_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03625 PyObject *resultobj = 0;
03626 PBEparm *arg1 = (PBEparm *) 0 ;
03627 double arg2 ;
03628 void *argp1 = 0 ;
03629 int res1 = 0 ;
03630 double val2 ;
03631 int ecode2 = 0 ;
03632 PyObject * obj0 = 0 ;
03633 PyObject * obj1 = 0 ;
03634
03635 if (!PyArg_ParseTuple(args,(char *)"OO:PBEparm_temp_set",&obj0,&obj1)) SWIG_fail;
03636 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PBEparm, 0 | 0 );
03637 if (!SWIG_IsOK(res1)) {
03638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PBEparm_temp_set" "', argument " "1"" of type '" "PBEparm *""'");
03639 }
03640 arg1 = (PBEparm *)(argp1);
03641 ecode2 = SWIG_AsVal_double(obj1, &val2);
03642 if (!SWIG_IsOK(ecode2)) {
03643 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PBEparm_temp_set" "', argument " "2"" of type '" "double""'");
03644 }
03645 arg2 = (double)(val2);
03646 if (arg1) (arg1)->temp = arg2;
03647
03648 resultobj = SWIG_Py_Void();
03649 return resultobj;
03650 fail:
03651 return NULL;
03652 }
03653
03654
03655 SWIGINTERN PyObject *_wrap_PBEparm_temp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03656 PyObject *resultobj = 0;
03657 PBEparm *arg1 = (PBEparm *) 0 ;
03658 double result;
03659 void *argp1 = 0 ;
03660 int res1 = 0 ;
03661 PyObject * obj0 = 0 ;
03662
03663 if (!PyArg_ParseTuple(args,(char *)"O:PBEparm_temp_get",&obj0)) SWIG_fail;
03664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PBEparm, 0 | 0 );
03665 if (!SWIG_IsOK(res1)) {
03666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PBEparm_temp_get" "', argument " "1"" of type '" "PBEparm *""'");
03667 }
03668 arg1 = (PBEparm *)(argp1);
03669 result = (double) ((arg1)->temp);
03670 resultobj = SWIG_From_double((double)(result));
03671 return resultobj;
03672 fail:
03673 return NULL;
03674 }
03675
03676
03677 SWIGINTERN PyObject *_wrap_PBEparm_pdie_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03678 PyObject *resultobj = 0;
03679 PBEparm *arg1 = (PBEparm *) 0 ;
03680 double arg2 ;
03681 void *argp1 = 0 ;
03682 int res1 = 0 ;
03683 double val2 ;
03684 int ecode2 = 0 ;
03685 PyObject * obj0 = 0 ;
03686 PyObject * obj1 = 0 ;
03687
03688 if (!PyArg_ParseTuple(args,(char *)"OO:PBEparm_pdie_set",&obj0,&obj1)) SWIG_fail;
03689 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PBEparm, 0 | 0 );
03690 if (!SWIG_IsOK(res1)) {
03691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PBEparm_pdie_set" "', argument " "1"" of type '" "PBEparm *""'");
03692 }
03693 arg1 = (PBEparm *)(argp1);
03694 ecode2 = SWIG_AsVal_double(obj1, &val2);
03695 if (!SWIG_IsOK(ecode2)) {
03696 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PBEparm_pdie_set" "', argument " "2"" of type '" "double""'");
03697 }
03698 arg2 = (double)(val2);
03699 if (arg1) (arg1)->pdie = arg2;
03700
03701 resultobj = SWIG_Py_Void();
03702 return resultobj;
03703 fail:
03704 return NULL;
03705 }
03706
03707
03708 SWIGINTERN PyObject *_wrap_PBEparm_pdie_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03709 PyObject *resultobj = 0;
03710 PBEparm *arg1 = (PBEparm *) 0 ;
03711 double result;
03712 void *argp1 = 0 ;
03713 int res1 = 0 ;
03714 PyObject * obj0 = 0 ;
03715
03716 if (!PyArg_ParseTuple(args,(char *)"O:PBEparm_pdie_get",&obj0)) SWIG_fail;
03717 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PBEparm, 0 | 0 );
03718 if (!SWIG_IsOK(res1)) {
03719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PBEparm_pdie_get" "', argument " "1"" of type '" "PBEparm *""'");
03720 }
03721 arg1 = (PBEparm *)(argp1);
03722 result = (double) ((arg1)->pdie);
03723 resultobj = SWIG_From_double((double)(result));
03724 return resultobj;
03725 fail:
03726 return NULL;
03727 }
03728
03729
03730 SWIGINTERN PyObject *_wrap_PBEparm_sdie_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03731 PyObject *resultobj = 0;
03732 PBEparm *arg1 = (PBEparm *) 0 ;
03733 double arg2 ;
03734 void *argp1 = 0 ;
03735 int res1 = 0 ;
03736 double val2 ;
03737 int ecode2 = 0 ;
03738 PyObject * obj0 = 0 ;
03739 PyObject * obj1 = 0 ;
03740
03741 if (!PyArg_ParseTuple(args,(char *)"OO:PBEparm_sdie_set",&obj0,&obj1)) SWIG_fail;
03742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PBEparm, 0 | 0 );
03743 if (!SWIG_IsOK(res1)) {
03744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PBEparm_sdie_set" "', argument " "1"" of type '" "PBEparm *""'");
03745 }
03746 arg1 = (PBEparm *)(argp1);
03747 ecode2 = SWIG_AsVal_double(obj1, &val2);
03748 if (!SWIG_IsOK(ecode2)) {
03749 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PBEparm_sdie_set" "', argument " "2"" of type '" "double""'");
03750 }
03751 arg2 = (double)(val2);
03752 if (arg1) (arg1)->sdie = arg2;
03753
03754 resultobj = SWIG_Py_Void();
03755 return resultobj;
03756 fail:
03757 return NULL;
03758 }
03759
03760
03761 SWIGINTERN PyObject *_wrap_PBEparm_sdie_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03762 PyObject *resultobj = 0;
03763 PBEparm *arg1 = (PBEparm *) 0 ;
03764 double result;
03765 void *argp1 = 0 ;
03766 int res1 = 0 ;
03767 PyObject * obj0 = 0 ;
03768
03769 if (!PyArg_ParseTuple(args,(char *)"O:PBEparm_sdie_get",&obj0)) SWIG_fail;
03770 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PBEparm, 0 | 0 );
03771 if (!SWIG_IsOK(res1)) {
03772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PBEparm_sdie_get" "', argument " "1"" of type '" "PBEparm *""'");
03773 }
03774 arg1 = (PBEparm *)(argp1);
03775 result = (double) ((arg1)->sdie);
03776 resultobj = SWIG_From_double((double)(result));
03777 return resultobj;
03778 fail:
03779 return NULL;
03780 }
03781
03782
03783 SWIGINTERN PyObject *_wrap_PBEparm_molid_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03784 PyObject *resultobj = 0;
03785 PBEparm *arg1 = (PBEparm *) 0 ;
03786 int arg2 ;
03787 void *argp1 = 0 ;
03788 int res1 = 0 ;
03789 int val2 ;
03790 int ecode2 = 0 ;
03791 PyObject * obj0 = 0 ;
03792 PyObject * obj1 = 0 ;
03793
03794 if (!PyArg_ParseTuple(args,(char *)"OO:PBEparm_molid_set",&obj0,&obj1)) SWIG_fail;
03795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PBEparm, 0 | 0 );
03796 if (!SWIG_IsOK(res1)) {
03797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PBEparm_molid_set" "', argument " "1"" of type '" "PBEparm *""'");
03798 }
03799 arg1 = (PBEparm *)(argp1);
03800 ecode2 = SWIG_AsVal_int(obj1, &val2);
03801 if (!SWIG_IsOK(ecode2)) {
03802 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PBEparm_molid_set" "', argument " "2"" of type '" "int""'");
03803 }
03804 arg2 = (int)(val2);
03805 if (arg1) (arg1)->molid = arg2;
03806
03807 resultobj = SWIG_Py_Void();
03808 return resultobj;
03809 fail:
03810 return NULL;
03811 }
03812
03813
03814 SWIGINTERN PyObject *_wrap_PBEparm_molid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03815 PyObject *resultobj = 0;
03816 PBEparm *arg1 = (PBEparm *) 0 ;
03817 int result;
03818 void *argp1 = 0 ;
03819 int res1 = 0 ;
03820 PyObject * obj0 = 0 ;
03821
03822 if (!PyArg_ParseTuple(args,(char *)"O:PBEparm_molid_get",&obj0)) SWIG_fail;
03823 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PBEparm, 0 | 0 );
03824 if (!SWIG_IsOK(res1)) {
03825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PBEparm_molid_get" "', argument " "1"" of type '" "PBEparm *""'");
03826 }
03827 arg1 = (PBEparm *)(argp1);
03828 result = (int) ((arg1)->molid);
03829 resultobj = SWIG_From_int((int)(result));
03830 return resultobj;
03831 fail:
03832 return NULL;
03833 }
03834
03835
03836 SWIGINTERN PyObject *PBEparm_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03837 PyObject *obj;
03838 if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
03839 SWIG_TypeNewClientData(SWIGTYPE_p_PBEparm, SWIG_NewClientData(obj));
03840 return SWIG_Py_Void();
03841 }
03842
03843 SWIGINTERN PyObject *_wrap_new_Vcom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03844 PyObject *resultobj = 0;
03845 Vcom *result = 0 ;
03846
03847 if (!PyArg_ParseTuple(args,(char *)":new_Vcom")) SWIG_fail;
03848 result = (Vcom *)(Vcom *) calloc(1, sizeof(Vcom));
03849 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Vcom, SWIG_POINTER_NEW | 0 );
03850 return resultobj;
03851 fail:
03852 return NULL;
03853 }
03854
03855
03856 SWIGINTERN PyObject *_wrap_delete_Vcom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03857 PyObject *resultobj = 0;
03858 Vcom *arg1 = (Vcom *) 0 ;
03859 void *argp1 = 0 ;
03860 int res1 = 0 ;
03861 PyObject * obj0 = 0 ;
03862
03863 if (!PyArg_ParseTuple(args,(char *)"O:delete_Vcom",&obj0)) SWIG_fail;
03864 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Vcom, SWIG_POINTER_DISOWN | 0 );
03865 if (!SWIG_IsOK(res1)) {
03866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Vcom" "', argument " "1"" of type '" "Vcom *""'");
03867 }
03868 arg1 = (Vcom *)(argp1);
03869 free((char *) arg1);
03870
03871 resultobj = SWIG_Py_Void();
03872 return resultobj;
03873 fail:
03874 return NULL;
03875 }
03876
03877
03878 SWIGINTERN PyObject *Vcom_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03879 PyObject *obj;
03880 if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
03881 SWIG_TypeNewClientData(SWIGTYPE_p_Vcom, SWIG_NewClientData(obj));
03882 return SWIG_Py_Void();
03883 }
03884
03885 SWIGINTERN PyObject *_wrap_Vcom_ctor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03886 PyObject *resultobj = 0;
03887 int arg1 ;
03888 Vcom *result = 0 ;
03889 int val1 ;
03890 int ecode1 = 0 ;
03891 PyObject * obj0 = 0 ;
03892
03893 if (!PyArg_ParseTuple(args,(char *)"O:Vcom_ctor",&obj0)) SWIG_fail;
03894 ecode1 = SWIG_AsVal_int(obj0, &val1);
03895 if (!SWIG_IsOK(ecode1)) {
03896 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Vcom_ctor" "', argument " "1"" of type '" "int""'");
03897 }
03898 arg1 = (int)(val1);
03899 result = (Vcom *)Vcom_ctor(arg1);
03900 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Vcom, 0 | 0 );
03901 return resultobj;
03902 fail:
03903 return NULL;
03904 }
03905
03906
03907 SWIGINTERN PyObject *_wrap_Vcom_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03908 PyObject *resultobj = 0;
03909 Vcom *arg1 = (Vcom *) 0 ;
03910 int result;
03911 void *argp1 = 0 ;
03912 int res1 = 0 ;
03913 PyObject * obj0 = 0 ;
03914
03915 if (!PyArg_ParseTuple(args,(char *)"O:Vcom_size",&obj0)) SWIG_fail;
03916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Vcom, 0 | 0 );
03917 if (!SWIG_IsOK(res1)) {
03918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vcom_size" "', argument " "1"" of type '" "Vcom *""'");
03919 }
03920 arg1 = (Vcom *)(argp1);
03921 result = (int)Vcom_size(arg1);
03922 resultobj = SWIG_From_int((int)(result));
03923 return resultobj;
03924 fail:
03925 return NULL;
03926 }
03927
03928
03929 SWIGINTERN PyObject *_wrap_Vcom_rank(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03930 PyObject *resultobj = 0;
03931 Vcom *arg1 = (Vcom *) 0 ;
03932 int result;
03933 void *argp1 = 0 ;
03934 int res1 = 0 ;
03935 PyObject * obj0 = 0 ;
03936
03937 if (!PyArg_ParseTuple(args,(char *)"O:Vcom_rank",&obj0)) SWIG_fail;
03938 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Vcom, 0 | 0 );
03939 if (!SWIG_IsOK(res1)) {
03940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vcom_rank" "', argument " "1"" of type '" "Vcom *""'");
03941 }
03942 arg1 = (Vcom *)(argp1);
03943 result = (int)Vcom_rank(arg1);
03944 resultobj = SWIG_From_int((int)(result));
03945 return resultobj;
03946 fail:
03947 return NULL;
03948 }
03949
03950
03951 SWIGINTERN PyObject *_wrap_new_Vmem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03952 PyObject *resultobj = 0;
03953 Vmem *result = 0 ;
03954
03955 if (!PyArg_ParseTuple(args,(char *)":new_Vmem")) SWIG_fail;
03956 result = (Vmem *)(Vmem *) calloc(1, sizeof(Vmem));
03957 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Vmem, SWIG_POINTER_NEW | 0 );
03958 return resultobj;
03959 fail:
03960 return NULL;
03961 }
03962
03963
03964 SWIGINTERN PyObject *_wrap_delete_Vmem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03965 PyObject *resultobj = 0;
03966 Vmem *arg1 = (Vmem *) 0 ;
03967 void *argp1 = 0 ;
03968 int res1 = 0 ;
03969 PyObject * obj0 = 0 ;
03970
03971 if (!PyArg_ParseTuple(args,(char *)"O:delete_Vmem",&obj0)) SWIG_fail;
03972 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Vmem, SWIG_POINTER_DISOWN | 0 );
03973 if (!SWIG_IsOK(res1)) {
03974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Vmem" "', argument " "1"" of type '" "Vmem *""'");
03975 }
03976 arg1 = (Vmem *)(argp1);
03977 free((char *) arg1);
03978
03979 resultobj = SWIG_Py_Void();
03980 return resultobj;
03981 fail:
03982 return NULL;
03983 }
03984
03985
03986 SWIGINTERN PyObject *Vmem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03987 PyObject *obj;
03988 if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
03989 SWIG_TypeNewClientData(SWIGTYPE_p_Vmem, SWIG_NewClientData(obj));
03990 return SWIG_Py_Void();
03991 }
03992
03993 SWIGINTERN PyObject *_wrap_Vmem_ctor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
03994 PyObject *resultobj = 0;
03995 char *arg1 = (char *) 0 ;
03996 Vmem *result = 0 ;
03997 int res1 ;
03998 char *buf1 = 0 ;
03999 int alloc1 = 0 ;
04000 PyObject * obj0 = 0 ;
04001
04002 if (!PyArg_ParseTuple(args,(char *)"O:Vmem_ctor",&obj0)) SWIG_fail;
04003 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
04004 if (!SWIG_IsOK(res1)) {
04005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vmem_ctor" "', argument " "1"" of type '" "char *""'");
04006 }
04007 arg1 = (char *)(buf1);
04008 result = (Vmem *)Vmem_ctor(arg1);
04009 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Vmem, 0 | 0 );
04010 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
04011 return resultobj;
04012 fail:
04013 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
04014 return NULL;
04015 }
04016
04017
04018 SWIGINTERN PyObject *_wrap_new_Vpmg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04019 PyObject *resultobj = 0;
04020 Vpmg *result = 0 ;
04021
04022 if (!PyArg_ParseTuple(args,(char *)":new_Vpmg")) SWIG_fail;
04023 result = (Vpmg *)(Vpmg *) calloc(1, sizeof(Vpmg));
04024 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Vpmg, SWIG_POINTER_NEW | 0 );
04025 return resultobj;
04026 fail:
04027 return NULL;
04028 }
04029
04030
04031 SWIGINTERN PyObject *_wrap_delete_Vpmg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04032 PyObject *resultobj = 0;
04033 Vpmg *arg1 = (Vpmg *) 0 ;
04034 void *argp1 = 0 ;
04035 int res1 = 0 ;
04036 PyObject * obj0 = 0 ;
04037
04038 if (!PyArg_ParseTuple(args,(char *)"O:delete_Vpmg",&obj0)) SWIG_fail;
04039 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Vpmg, SWIG_POINTER_DISOWN | 0 );
04040 if (!SWIG_IsOK(res1)) {
04041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Vpmg" "', argument " "1"" of type '" "Vpmg *""'");
04042 }
04043 arg1 = (Vpmg *)(argp1);
04044 free((char *) arg1);
04045
04046 resultobj = SWIG_Py_Void();
04047 return resultobj;
04048 fail:
04049 return NULL;
04050 }
04051
04052
04053 SWIGINTERN PyObject *Vpmg_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04054 PyObject *obj;
04055 if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
04056 SWIG_TypeNewClientData(SWIGTYPE_p_Vpmg, SWIG_NewClientData(obj));
04057 return SWIG_Py_Void();
04058 }
04059
04060 SWIGINTERN PyObject *_wrap_new_Vpbe(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04061 PyObject *resultobj = 0;
04062 Vpbe *result = 0 ;
04063
04064 if (!PyArg_ParseTuple(args,(char *)":new_Vpbe")) SWIG_fail;
04065 result = (Vpbe *)(Vpbe *) calloc(1, sizeof(Vpbe));
04066 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Vpbe, SWIG_POINTER_NEW | 0 );
04067 return resultobj;
04068 fail:
04069 return NULL;
04070 }
04071
04072
04073 SWIGINTERN PyObject *_wrap_delete_Vpbe(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04074 PyObject *resultobj = 0;
04075 Vpbe *arg1 = (Vpbe *) 0 ;
04076 void *argp1 = 0 ;
04077 int res1 = 0 ;
04078 PyObject * obj0 = 0 ;
04079
04080 if (!PyArg_ParseTuple(args,(char *)"O:delete_Vpbe",&obj0)) SWIG_fail;
04081 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Vpbe, SWIG_POINTER_DISOWN | 0 );
04082 if (!SWIG_IsOK(res1)) {
04083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Vpbe" "', argument " "1"" of type '" "Vpbe *""'");
04084 }
04085 arg1 = (Vpbe *)(argp1);
04086 free((char *) arg1);
04087
04088 resultobj = SWIG_Py_Void();
04089 return resultobj;
04090 fail:
04091 return NULL;
04092 }
04093
04094
04095 SWIGINTERN PyObject *_wrap_Vpbe_acc_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04096 PyObject *resultobj = 0;
04097 Vpbe *arg1 = (Vpbe *) 0 ;
04098 Vacc *arg2 = (Vacc *) 0 ;
04099 void *argp1 = 0 ;
04100 int res1 = 0 ;
04101 void *argp2 = 0 ;
04102 int res2 = 0 ;
04103 PyObject * obj0 = 0 ;
04104 PyObject * obj1 = 0 ;
04105
04106 if (!PyArg_ParseTuple(args,(char *)"OO:Vpbe_acc_set",&obj0,&obj1)) SWIG_fail;
04107 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Vpbe, 0 | 0 );
04108 if (!SWIG_IsOK(res1)) {
04109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vpbe_acc_set" "', argument " "1"" of type '" "Vpbe *""'");
04110 }
04111 arg1 = (Vpbe *)(argp1);
04112 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Vacc, SWIG_POINTER_DISOWN | 0 );
04113 if (!SWIG_IsOK(res2)) {
04114 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vpbe_acc_set" "', argument " "2"" of type '" "Vacc *""'");
04115 }
04116 arg2 = (Vacc *)(argp2);
04117 if (arg1) (arg1)->acc = arg2;
04118
04119 resultobj = SWIG_Py_Void();
04120 return resultobj;
04121 fail:
04122 return NULL;
04123 }
04124
04125
04126 SWIGINTERN PyObject *_wrap_Vpbe_acc_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04127 PyObject *resultobj = 0;
04128 Vpbe *arg1 = (Vpbe *) 0 ;
04129 Vacc *result = 0 ;
04130 void *argp1 = 0 ;
04131 int res1 = 0 ;
04132 PyObject * obj0 = 0 ;
04133
04134 if (!PyArg_ParseTuple(args,(char *)"O:Vpbe_acc_get",&obj0)) SWIG_fail;
04135 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Vpbe, 0 | 0 );
04136 if (!SWIG_IsOK(res1)) {
04137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vpbe_acc_get" "', argument " "1"" of type '" "Vpbe *""'");
04138 }
04139 arg1 = (Vpbe *)(argp1);
04140 result = (Vacc *) ((arg1)->acc);
04141 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Vacc, 0 | 0 );
04142 return resultobj;
04143 fail:
04144 return NULL;
04145 }
04146
04147
04148 SWIGINTERN PyObject *Vpbe_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04149 PyObject *obj;
04150 if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
04151 SWIG_TypeNewClientData(SWIGTYPE_p_Vpbe, SWIG_NewClientData(obj));
04152 return SWIG_Py_Void();
04153 }
04154
04155 SWIGINTERN PyObject *_wrap_new_NOsh_calc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04156 PyObject *resultobj = 0;
04157 NOsh_calc *result = 0 ;
04158
04159 if (!PyArg_ParseTuple(args,(char *)":new_NOsh_calc")) SWIG_fail;
04160 result = (NOsh_calc *)(NOsh_calc *) calloc(1, sizeof(NOsh_calc));
04161 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_NOsh_calc, SWIG_POINTER_NEW | 0 );
04162 return resultobj;
04163 fail:
04164 return NULL;
04165 }
04166
04167
04168 SWIGINTERN PyObject *_wrap_delete_NOsh_calc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04169 PyObject *resultobj = 0;
04170 NOsh_calc *arg1 = (NOsh_calc *) 0 ;
04171 void *argp1 = 0 ;
04172 int res1 = 0 ;
04173 PyObject * obj0 = 0 ;
04174
04175 if (!PyArg_ParseTuple(args,(char *)"O:delete_NOsh_calc",&obj0)) SWIG_fail;
04176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_NOsh_calc, SWIG_POINTER_DISOWN | 0 );
04177 if (!SWIG_IsOK(res1)) {
04178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NOsh_calc" "', argument " "1"" of type '" "NOsh_calc *""'");
04179 }
04180 arg1 = (NOsh_calc *)(argp1);
04181 free((char *) arg1);
04182
04183 resultobj = SWIG_Py_Void();
04184 return resultobj;
04185 fail:
04186 return NULL;
04187 }
04188
04189
04190 SWIGINTERN PyObject *_wrap_NOsh_calc_mgparm_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04191 PyObject *resultobj = 0;
04192 NOsh_calc *arg1 = (NOsh_calc *) 0 ;
04193 MGparm *arg2 = (MGparm *) 0 ;
04194 void *argp1 = 0 ;
04195 int res1 = 0 ;
04196 void *argp2 = 0 ;
04197 int res2 = 0 ;
04198 PyObject * obj0 = 0 ;
04199 PyObject * obj1 = 0 ;
04200
04201 if (!PyArg_ParseTuple(args,(char *)"OO:NOsh_calc_mgparm_set",&obj0,&obj1)) SWIG_fail;
04202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_NOsh_calc, 0 | 0 );
04203 if (!SWIG_IsOK(res1)) {
04204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NOsh_calc_mgparm_set" "', argument " "1"" of type '" "NOsh_calc *""'");
04205 }
04206 arg1 = (NOsh_calc *)(argp1);
04207 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_MGparm, SWIG_POINTER_DISOWN | 0 );
04208 if (!SWIG_IsOK(res2)) {
04209 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NOsh_calc_mgparm_set" "', argument " "2"" of type '" "MGparm *""'");
04210 }
04211 arg2 = (MGparm *)(argp2);
04212 if (arg1) (arg1)->mgparm = arg2;
04213
04214 resultobj = SWIG_Py_Void();
04215 return resultobj;
04216 fail:
04217 return NULL;
04218 }
04219
04220
04221 SWIGINTERN PyObject *_wrap_NOsh_calc_mgparm_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04222 PyObject *resultobj = 0;
04223 NOsh_calc *arg1 = (NOsh_calc *) 0 ;
04224 MGparm *result = 0 ;
04225 void *argp1 = 0 ;
04226 int res1 = 0 ;
04227 PyObject * obj0 = 0 ;
04228
04229 if (!PyArg_ParseTuple(args,(char *)"O:NOsh_calc_mgparm_get",&obj0)) SWIG_fail;
04230 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_NOsh_calc, 0 | 0 );
04231 if (!SWIG_IsOK(res1)) {
04232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NOsh_calc_mgparm_get" "', argument " "1"" of type '" "NOsh_calc *""'");
04233 }
04234 arg1 = (NOsh_calc *)(argp1);
04235 result = (MGparm *) ((arg1)->mgparm);
04236 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MGparm, 0 | 0 );
04237 return resultobj;
04238 fail:
04239 return NULL;
04240 }
04241
04242
04243 SWIGINTERN PyObject *_wrap_NOsh_calc_femparm_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04244 PyObject *resultobj = 0;
04245 NOsh_calc *arg1 = (NOsh_calc *) 0 ;
04246 FEMparm *arg2 = (FEMparm *) 0 ;
04247 void *argp1 = 0 ;
04248 int res1 = 0 ;
04249 void *argp2 = 0 ;
04250 int res2 = 0 ;
04251 PyObject * obj0 = 0 ;
04252 PyObject * obj1 = 0 ;
04253
04254 if (!PyArg_ParseTuple(args,(char *)"OO:NOsh_calc_femparm_set",&obj0,&obj1)) SWIG_fail;
04255 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_NOsh_calc, 0 | 0 );
04256 if (!SWIG_IsOK(res1)) {
04257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NOsh_calc_femparm_set" "', argument " "1"" of type '" "NOsh_calc *""'");
04258 }
04259 arg1 = (NOsh_calc *)(argp1);
04260 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_FEMparm, SWIG_POINTER_DISOWN | 0 );
04261 if (!SWIG_IsOK(res2)) {
04262 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NOsh_calc_femparm_set" "', argument " "2"" of type '" "FEMparm *""'");
04263 }
04264 arg2 = (FEMparm *)(argp2);
04265 if (arg1) (arg1)->femparm = arg2;
04266
04267 resultobj = SWIG_Py_Void();
04268 return resultobj;
04269 fail:
04270 return NULL;
04271 }
04272
04273
04274 SWIGINTERN PyObject *_wrap_NOsh_calc_femparm_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04275 PyObject *resultobj = 0;
04276 NOsh_calc *arg1 = (NOsh_calc *) 0 ;
04277 FEMparm *result = 0 ;
04278 void *argp1 = 0 ;
04279 int res1 = 0 ;
04280 PyObject * obj0 = 0 ;
04281
04282 if (!PyArg_ParseTuple(args,(char *)"O:NOsh_calc_femparm_get",&obj0)) SWIG_fail;
04283 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_NOsh_calc, 0 | 0 );
04284 if (!SWIG_IsOK(res1)) {
04285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NOsh_calc_femparm_get" "', argument " "1"" of type '" "NOsh_calc *""'");
04286 }
04287 arg1 = (NOsh_calc *)(argp1);
04288 result = (FEMparm *) ((arg1)->femparm);
04289 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FEMparm, 0 | 0 );
04290 return resultobj;
04291 fail:
04292 return NULL;
04293 }
04294
04295
04296 SWIGINTERN PyObject *_wrap_NOsh_calc_pbeparm_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04297 PyObject *resultobj = 0;
04298 NOsh_calc *arg1 = (NOsh_calc *) 0 ;
04299 PBEparm *arg2 = (PBEparm *) 0 ;
04300 void *argp1 = 0 ;
04301 int res1 = 0 ;
04302 void *argp2 = 0 ;
04303 int res2 = 0 ;
04304 PyObject * obj0 = 0 ;
04305 PyObject * obj1 = 0 ;
04306
04307 if (!PyArg_ParseTuple(args,(char *)"OO:NOsh_calc_pbeparm_set",&obj0,&obj1)) SWIG_fail;
04308 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_NOsh_calc, 0 | 0 );
04309 if (!SWIG_IsOK(res1)) {
04310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NOsh_calc_pbeparm_set" "', argument " "1"" of type '" "NOsh_calc *""'");
04311 }
04312 arg1 = (NOsh_calc *)(argp1);
04313 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_PBEparm, SWIG_POINTER_DISOWN | 0 );
04314 if (!SWIG_IsOK(res2)) {
04315 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NOsh_calc_pbeparm_set" "', argument " "2"" of type '" "PBEparm *""'");
04316 }
04317 arg2 = (PBEparm *)(argp2);
04318 if (arg1) (arg1)->pbeparm = arg2;
04319
04320 resultobj = SWIG_Py_Void();
04321 return resultobj;
04322 fail:
04323 return NULL;
04324 }
04325
04326
04327 SWIGINTERN PyObject *_wrap_NOsh_calc_pbeparm_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04328 PyObject *resultobj = 0;
04329 NOsh_calc *arg1 = (NOsh_calc *) 0 ;
04330 PBEparm *result = 0 ;
04331 void *argp1 = 0 ;
04332 int res1 = 0 ;
04333 PyObject * obj0 = 0 ;
04334
04335 if (!PyArg_ParseTuple(args,(char *)"O:NOsh_calc_pbeparm_get",&obj0)) SWIG_fail;
04336 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_NOsh_calc, 0 | 0 );
04337 if (!SWIG_IsOK(res1)) {
04338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NOsh_calc_pbeparm_get" "', argument " "1"" of type '" "NOsh_calc *""'");
04339 }
04340 arg1 = (NOsh_calc *)(argp1);
04341 result = (PBEparm *) ((arg1)->pbeparm);
04342 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_PBEparm, 0 | 0 );
04343 return resultobj;
04344 fail:
04345 return NULL;
04346 }
04347
04348
04349 SWIGINTERN PyObject *_wrap_NOsh_calc_calctype_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04350 PyObject *resultobj = 0;
04351 NOsh_calc *arg1 = (NOsh_calc *) 0 ;
04352 int arg2 ;
04353 void *argp1 = 0 ;
04354 int res1 = 0 ;
04355 int val2 ;
04356 int ecode2 = 0 ;
04357 PyObject * obj0 = 0 ;
04358 PyObject * obj1 = 0 ;
04359
04360 if (!PyArg_ParseTuple(args,(char *)"OO:NOsh_calc_calctype_set",&obj0,&obj1)) SWIG_fail;
04361 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_NOsh_calc, 0 | 0 );
04362 if (!SWIG_IsOK(res1)) {
04363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NOsh_calc_calctype_set" "', argument " "1"" of type '" "NOsh_calc *""'");
04364 }
04365 arg1 = (NOsh_calc *)(argp1);
04366 ecode2 = SWIG_AsVal_int(obj1, &val2);
04367 if (!SWIG_IsOK(ecode2)) {
04368 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NOsh_calc_calctype_set" "', argument " "2"" of type '" "int""'");
04369 }
04370 arg2 = (int)(val2);
04371 if (arg1) (arg1)->calctype = arg2;
04372
04373 resultobj = SWIG_Py_Void();
04374 return resultobj;
04375 fail:
04376 return NULL;
04377 }
04378
04379
04380 SWIGINTERN PyObject *_wrap_NOsh_calc_calctype_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04381 PyObject *resultobj = 0;
04382 NOsh_calc *arg1 = (NOsh_calc *) 0 ;
04383 int result;
04384 void *argp1 = 0 ;
04385 int res1 = 0 ;
04386 PyObject * obj0 = 0 ;
04387
04388 if (!PyArg_ParseTuple(args,(char *)"O:NOsh_calc_calctype_get",&obj0)) SWIG_fail;
04389 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_NOsh_calc, 0 | 0 );
04390 if (!SWIG_IsOK(res1)) {
04391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NOsh_calc_calctype_get" "', argument " "1"" of type '" "NOsh_calc *""'");
04392 }
04393 arg1 = (NOsh_calc *)(argp1);
04394 result = (int) ((arg1)->calctype);
04395 resultobj = SWIG_From_int((int)(result));
04396 return resultobj;
04397 fail:
04398 return NULL;
04399 }
04400
04401
04402 SWIGINTERN PyObject *NOsh_calc_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04403 PyObject *obj;
04404 if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
04405 SWIG_TypeNewClientData(SWIGTYPE_p_NOsh_calc, SWIG_NewClientData(obj));
04406 return SWIG_Py_Void();
04407 }
04408
04409 SWIGINTERN PyObject *_wrap_new_NOsh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04410 PyObject *resultobj = 0;
04411 NOsh *result = 0 ;
04412
04413 if (!PyArg_ParseTuple(args,(char *)":new_NOsh")) SWIG_fail;
04414 result = (NOsh *)(NOsh *) calloc(1, sizeof(NOsh));
04415 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_NOsh, SWIG_POINTER_NEW | 0 );
04416 return resultobj;
04417 fail:
04418 return NULL;
04419 }
04420
04421
04422 SWIGINTERN PyObject *_wrap_delete_NOsh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04423 PyObject *resultobj = 0;
04424 NOsh *arg1 = (NOsh *) 0 ;
04425 void *argp1 = 0 ;
04426 int res1 = 0 ;
04427 PyObject * obj0 = 0 ;
04428
04429 if (!PyArg_ParseTuple(args,(char *)"O:delete_NOsh",&obj0)) SWIG_fail;
04430 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_NOsh, SWIG_POINTER_DISOWN | 0 );
04431 if (!SWIG_IsOK(res1)) {
04432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NOsh" "', argument " "1"" of type '" "NOsh *""'");
04433 }
04434 arg1 = (NOsh *)(argp1);
04435 free((char *) arg1);
04436
04437 resultobj = SWIG_Py_Void();
04438 return resultobj;
04439 fail:
04440 return NULL;
04441 }
04442
04443
04444 SWIGINTERN PyObject *_wrap_NOsh_ncalc_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04445 PyObject *resultobj = 0;
04446 NOsh *arg1 = (NOsh *) 0 ;
04447 int arg2 ;
04448 void *argp1 = 0 ;
04449 int res1 = 0 ;
04450 int val2 ;
04451 int ecode2 = 0 ;
04452 PyObject * obj0 = 0 ;
04453 PyObject * obj1 = 0 ;
04454
04455 if (!PyArg_ParseTuple(args,(char *)"OO:NOsh_ncalc_set",&obj0,&obj1)) SWIG_fail;
04456 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_NOsh, 0 | 0 );
04457 if (!SWIG_IsOK(res1)) {
04458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NOsh_ncalc_set" "', argument " "1"" of type '" "NOsh *""'");
04459 }
04460 arg1 = (NOsh *)(argp1);
04461 ecode2 = SWIG_AsVal_int(obj1, &val2);
04462 if (!SWIG_IsOK(ecode2)) {
04463 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NOsh_ncalc_set" "', argument " "2"" of type '" "int""'");
04464 }
04465 arg2 = (int)(val2);
04466 if (arg1) (arg1)->ncalc = arg2;
04467
04468 resultobj = SWIG_Py_Void();
04469 return resultobj;
04470 fail:
04471 return NULL;
04472 }
04473
04474
04475 SWIGINTERN PyObject *_wrap_NOsh_ncalc_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04476 PyObject *resultobj = 0;
04477 NOsh *arg1 = (NOsh *) 0 ;
04478 int result;
04479 void *argp1 = 0 ;
04480 int res1 = 0 ;
04481 PyObject * obj0 = 0 ;
04482
04483 if (!PyArg_ParseTuple(args,(char *)"O:NOsh_ncalc_get",&obj0)) SWIG_fail;
04484 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_NOsh, 0 | 0 );
04485 if (!SWIG_IsOK(res1)) {
04486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NOsh_ncalc_get" "', argument " "1"" of type '" "NOsh *""'");
04487 }
04488 arg1 = (NOsh *)(argp1);
04489 result = (int) ((arg1)->ncalc);
04490 resultobj = SWIG_From_int((int)(result));
04491 return resultobj;
04492 fail:
04493 return NULL;
04494 }
04495
04496
04497 SWIGINTERN PyObject *_wrap_NOsh_nprint_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04498 PyObject *resultobj = 0;
04499 NOsh *arg1 = (NOsh *) 0 ;
04500 int arg2 ;
04501 void *argp1 = 0 ;
04502 int res1 = 0 ;
04503 int val2 ;
04504 int ecode2 = 0 ;
04505 PyObject * obj0 = 0 ;
04506 PyObject * obj1 = 0 ;
04507
04508 if (!PyArg_ParseTuple(args,(char *)"OO:NOsh_nprint_set",&obj0,&obj1)) SWIG_fail;
04509 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_NOsh, 0 | 0 );
04510 if (!SWIG_IsOK(res1)) {
04511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NOsh_nprint_set" "', argument " "1"" of type '" "NOsh *""'");
04512 }
04513 arg1 = (NOsh *)(argp1);
04514 ecode2 = SWIG_AsVal_int(obj1, &val2);
04515 if (!SWIG_IsOK(ecode2)) {
04516 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NOsh_nprint_set" "', argument " "2"" of type '" "int""'");
04517 }
04518 arg2 = (int)(val2);
04519 if (arg1) (arg1)->nprint = arg2;
04520
04521 resultobj = SWIG_Py_Void();
04522 return resultobj;
04523 fail:
04524 return NULL;
04525 }
04526
04527
04528 SWIGINTERN PyObject *_wrap_NOsh_nprint_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04529 PyObject *resultobj = 0;
04530 NOsh *arg1 = (NOsh *) 0 ;
04531 int result;
04532 void *argp1 = 0 ;
04533 int res1 = 0 ;
04534 PyObject * obj0 = 0 ;
04535
04536 if (!PyArg_ParseTuple(args,(char *)"O:NOsh_nprint_get",&obj0)) SWIG_fail;
04537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_NOsh, 0 | 0 );
04538 if (!SWIG_IsOK(res1)) {
04539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NOsh_nprint_get" "', argument " "1"" of type '" "NOsh *""'");
04540 }
04541 arg1 = (NOsh *)(argp1);
04542 result = (int) ((arg1)->nprint);
04543 resultobj = SWIG_From_int((int)(result));
04544 return resultobj;
04545 fail:
04546 return NULL;
04547 }
04548
04549
04550 SWIGINTERN PyObject *_wrap_NOsh_nelec_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04551 PyObject *resultobj = 0;
04552 NOsh *arg1 = (NOsh *) 0 ;
04553 int arg2 ;
04554 void *argp1 = 0 ;
04555 int res1 = 0 ;
04556 int val2 ;
04557 int ecode2 = 0 ;
04558 PyObject * obj0 = 0 ;
04559 PyObject * obj1 = 0 ;
04560
04561 if (!PyArg_ParseTuple(args,(char *)"OO:NOsh_nelec_set",&obj0,&obj1)) SWIG_fail;
04562 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_NOsh, 0 | 0 );
04563 if (!SWIG_IsOK(res1)) {
04564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NOsh_nelec_set" "', argument " "1"" of type '" "NOsh *""'");
04565 }
04566 arg1 = (NOsh *)(argp1);
04567 ecode2 = SWIG_AsVal_int(obj1, &val2);
04568 if (!SWIG_IsOK(ecode2)) {
04569 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NOsh_nelec_set" "', argument " "2"" of type '" "int""'");
04570 }
04571 arg2 = (int)(val2);
04572 if (arg1) (arg1)->nelec = arg2;
04573
04574 resultobj = SWIG_Py_Void();
04575 return resultobj;
04576 fail:
04577 return NULL;
04578 }
04579
04580
04581 SWIGINTERN PyObject *_wrap_NOsh_nelec_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04582 PyObject *resultobj = 0;
04583 NOsh *arg1 = (NOsh *) 0 ;
04584 int result;
04585 void *argp1 = 0 ;
04586 int res1 = 0 ;
04587 PyObject * obj0 = 0 ;
04588
04589 if (!PyArg_ParseTuple(args,(char *)"O:NOsh_nelec_get",&obj0)) SWIG_fail;
04590 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_NOsh, 0 | 0 );
04591 if (!SWIG_IsOK(res1)) {
04592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NOsh_nelec_get" "', argument " "1"" of type '" "NOsh *""'");
04593 }
04594 arg1 = (NOsh *)(argp1);
04595 result = (int) ((arg1)->nelec);
04596 resultobj = SWIG_From_int((int)(result));
04597 return resultobj;
04598 fail:
04599 return NULL;
04600 }
04601
04602
04603 SWIGINTERN PyObject *_wrap_NOsh_nmol_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04604 PyObject *resultobj = 0;
04605 NOsh *arg1 = (NOsh *) 0 ;
04606 int arg2 ;
04607 void *argp1 = 0 ;
04608 int res1 = 0 ;
04609 int val2 ;
04610 int ecode2 = 0 ;
04611 PyObject * obj0 = 0 ;
04612 PyObject * obj1 = 0 ;
04613
04614 if (!PyArg_ParseTuple(args,(char *)"OO:NOsh_nmol_set",&obj0,&obj1)) SWIG_fail;
04615 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_NOsh, 0 | 0 );
04616 if (!SWIG_IsOK(res1)) {
04617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NOsh_nmol_set" "', argument " "1"" of type '" "NOsh *""'");
04618 }
04619 arg1 = (NOsh *)(argp1);
04620 ecode2 = SWIG_AsVal_int(obj1, &val2);
04621 if (!SWIG_IsOK(ecode2)) {
04622 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NOsh_nmol_set" "', argument " "2"" of type '" "int""'");
04623 }
04624 arg2 = (int)(val2);
04625 if (arg1) (arg1)->nmol = arg2;
04626
04627 resultobj = SWIG_Py_Void();
04628 return resultobj;
04629 fail:
04630 return NULL;
04631 }
04632
04633
04634 SWIGINTERN PyObject *_wrap_NOsh_nmol_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04635 PyObject *resultobj = 0;
04636 NOsh *arg1 = (NOsh *) 0 ;
04637 int result;
04638 void *argp1 = 0 ;
04639 int res1 = 0 ;
04640 PyObject * obj0 = 0 ;
04641
04642 if (!PyArg_ParseTuple(args,(char *)"O:NOsh_nmol_get",&obj0)) SWIG_fail;
04643 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_NOsh, 0 | 0 );
04644 if (!SWIG_IsOK(res1)) {
04645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NOsh_nmol_get" "', argument " "1"" of type '" "NOsh *""'");
04646 }
04647 arg1 = (NOsh *)(argp1);
04648 result = (int) ((arg1)->nmol);
04649 resultobj = SWIG_From_int((int)(result));
04650 return resultobj;
04651 fail:
04652 return NULL;
04653 }
04654
04655
04656 SWIGINTERN PyObject *_wrap_NOsh_printwhat_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04657 PyObject *resultobj = 0;
04658 NOsh *arg1 = (NOsh *) 0 ;
04659 NOsh_PrintType *arg2 ;
04660 void *argp1 = 0 ;
04661 int res1 = 0 ;
04662 void *argp2 = 0 ;
04663 int res2 = 0 ;
04664 PyObject * obj0 = 0 ;
04665 PyObject * obj1 = 0 ;
04666
04667 if (!PyArg_ParseTuple(args,(char *)"OO:NOsh_printwhat_set",&obj0,&obj1)) SWIG_fail;
04668 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_NOsh, 0 | 0 );
04669 if (!SWIG_IsOK(res1)) {
04670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NOsh_printwhat_set" "', argument " "1"" of type '" "NOsh *""'");
04671 }
04672 arg1 = (NOsh *)(argp1);
04673 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_NOsh_PrintType, 0 | 0 );
04674 if (!SWIG_IsOK(res2)) {
04675 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NOsh_printwhat_set" "', argument " "2"" of type '" "NOsh_PrintType [NOSH_MAXPRINT]""'");
04676 }
04677 arg2 = (NOsh_PrintType *)(argp2);
04678 {
04679 if (arg2) {
04680 size_t ii = 0;
04681 for (; ii < (size_t)NOSH_MAXPRINT; ++ii) arg1->printwhat[ii] = arg2[ii];
04682 } else {
04683 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""printwhat""' of type '""NOsh_PrintType [NOSH_MAXPRINT]""'");
04684 }
04685 }
04686 resultobj = SWIG_Py_Void();
04687 return resultobj;
04688 fail:
04689 return NULL;
04690 }
04691
04692
04693 SWIGINTERN PyObject *_wrap_NOsh_printwhat_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04694 PyObject *resultobj = 0;
04695 NOsh *arg1 = (NOsh *) 0 ;
04696 NOsh_PrintType *result = 0 ;
04697 void *argp1 = 0 ;
04698 int res1 = 0 ;
04699 PyObject * obj0 = 0 ;
04700
04701 if (!PyArg_ParseTuple(args,(char *)"O:NOsh_printwhat_get",&obj0)) SWIG_fail;
04702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_NOsh, 0 | 0 );
04703 if (!SWIG_IsOK(res1)) {
04704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NOsh_printwhat_get" "', argument " "1"" of type '" "NOsh *""'");
04705 }
04706 arg1 = (NOsh *)(argp1);
04707 result = (NOsh_PrintType *)(NOsh_PrintType *) ((arg1)->printwhat);
04708 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_NOsh_PrintType, 0 | 0 );
04709 return resultobj;
04710 fail:
04711 return NULL;
04712 }
04713
04714
04715 SWIGINTERN PyObject *NOsh_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04716 PyObject *obj;
04717 if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
04718 SWIG_TypeNewClientData(SWIGTYPE_p_NOsh, SWIG_NewClientData(obj));
04719 return SWIG_Py_Void();
04720 }
04721
04722 SWIGINTERN PyObject *_wrap_NOsh_getCalc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04723 PyObject *resultobj = 0;
04724 NOsh *arg1 = (NOsh *) 0 ;
04725 int arg2 ;
04726 NOsh_calc *result = 0 ;
04727 void *argp1 = 0 ;
04728 int res1 = 0 ;
04729 int val2 ;
04730 int ecode2 = 0 ;
04731 PyObject * obj0 = 0 ;
04732 PyObject * obj1 = 0 ;
04733
04734 if (!PyArg_ParseTuple(args,(char *)"OO:NOsh_getCalc",&obj0,&obj1)) SWIG_fail;
04735 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_NOsh, 0 | 0 );
04736 if (!SWIG_IsOK(res1)) {
04737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NOsh_getCalc" "', argument " "1"" of type '" "NOsh *""'");
04738 }
04739 arg1 = (NOsh *)(argp1);
04740 ecode2 = SWIG_AsVal_int(obj1, &val2);
04741 if (!SWIG_IsOK(ecode2)) {
04742 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NOsh_getCalc" "', argument " "2"" of type '" "int""'");
04743 }
04744 arg2 = (int)(val2);
04745 result = (NOsh_calc *)NOsh_getCalc(arg1,arg2);
04746 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_NOsh_calc, 0 | 0 );
04747 return resultobj;
04748 fail:
04749 return NULL;
04750 }
04751
04752
04753 SWIGINTERN PyObject *_wrap_NOsh_elecname(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04754 PyObject *resultobj = 0;
04755 NOsh *arg1 = (NOsh *) 0 ;
04756 int arg2 ;
04757 char *result = 0 ;
04758 void *argp1 = 0 ;
04759 int res1 = 0 ;
04760 int val2 ;
04761 int ecode2 = 0 ;
04762 PyObject * obj0 = 0 ;
04763 PyObject * obj1 = 0 ;
04764
04765 if (!PyArg_ParseTuple(args,(char *)"OO:NOsh_elecname",&obj0,&obj1)) SWIG_fail;
04766 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_NOsh, 0 | 0 );
04767 if (!SWIG_IsOK(res1)) {
04768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NOsh_elecname" "', argument " "1"" of type '" "NOsh *""'");
04769 }
04770 arg1 = (NOsh *)(argp1);
04771 ecode2 = SWIG_AsVal_int(obj1, &val2);
04772 if (!SWIG_IsOK(ecode2)) {
04773 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NOsh_elecname" "', argument " "2"" of type '" "int""'");
04774 }
04775 arg2 = (int)(val2);
04776 result = (char *)NOsh_elecname(arg1,arg2);
04777 resultobj = SWIG_FromCharPtr((const char *)result);
04778 return resultobj;
04779 fail:
04780 return NULL;
04781 }
04782
04783
04784 SWIGINTERN PyObject *_wrap_NOsh_elec2calc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04785 PyObject *resultobj = 0;
04786 NOsh *arg1 = (NOsh *) 0 ;
04787 int arg2 ;
04788 int result;
04789 void *argp1 = 0 ;
04790 int res1 = 0 ;
04791 int val2 ;
04792 int ecode2 = 0 ;
04793 PyObject * obj0 = 0 ;
04794 PyObject * obj1 = 0 ;
04795
04796 if (!PyArg_ParseTuple(args,(char *)"OO:NOsh_elec2calc",&obj0,&obj1)) SWIG_fail;
04797 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_NOsh, 0 | 0 );
04798 if (!SWIG_IsOK(res1)) {
04799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NOsh_elec2calc" "', argument " "1"" of type '" "NOsh *""'");
04800 }
04801 arg1 = (NOsh *)(argp1);
04802 ecode2 = SWIG_AsVal_int(obj1, &val2);
04803 if (!SWIG_IsOK(ecode2)) {
04804 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NOsh_elec2calc" "', argument " "2"" of type '" "int""'");
04805 }
04806 arg2 = (int)(val2);
04807 result = (int)NOsh_elec2calc(arg1,arg2);
04808 resultobj = SWIG_From_int((int)(result));
04809 return resultobj;
04810 fail:
04811 return NULL;
04812 }
04813
04814
04815 SWIGINTERN PyObject *_wrap_NOsh_printWhat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04816 PyObject *resultobj = 0;
04817 NOsh *arg1 = (NOsh *) 0 ;
04818 int arg2 ;
04819 NOsh_PrintType result;
04820 void *argp1 = 0 ;
04821 int res1 = 0 ;
04822 int val2 ;
04823 int ecode2 = 0 ;
04824 PyObject * obj0 = 0 ;
04825 PyObject * obj1 = 0 ;
04826
04827 if (!PyArg_ParseTuple(args,(char *)"OO:NOsh_printWhat",&obj0,&obj1)) SWIG_fail;
04828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_NOsh, 0 | 0 );
04829 if (!SWIG_IsOK(res1)) {
04830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NOsh_printWhat" "', argument " "1"" of type '" "NOsh *""'");
04831 }
04832 arg1 = (NOsh *)(argp1);
04833 ecode2 = SWIG_AsVal_int(obj1, &val2);
04834 if (!SWIG_IsOK(ecode2)) {
04835 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NOsh_printWhat" "', argument " "2"" of type '" "int""'");
04836 }
04837 arg2 = (int)(val2);
04838 result = (NOsh_PrintType)NOsh_printWhat(arg1,arg2);
04839 resultobj = SWIG_From_int((int)(result));
04840 return resultobj;
04841 fail:
04842 return NULL;
04843 }
04844
04845
04846 SWIGINTERN PyObject *_wrap_NOsh_parseInputFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04847 PyObject *resultobj = 0;
04848 NOsh *arg1 = (NOsh *) 0 ;
04849 char *arg2 = (char *) 0 ;
04850 int result;
04851 void *argp1 = 0 ;
04852 int res1 = 0 ;
04853 int res2 ;
04854 char *buf2 = 0 ;
04855 int alloc2 = 0 ;
04856 PyObject * obj0 = 0 ;
04857 PyObject * obj1 = 0 ;
04858
04859 if (!PyArg_ParseTuple(args,(char *)"OO:NOsh_parseInputFile",&obj0,&obj1)) SWIG_fail;
04860 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_NOsh, 0 | 0 );
04861 if (!SWIG_IsOK(res1)) {
04862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NOsh_parseInputFile" "', argument " "1"" of type '" "NOsh *""'");
04863 }
04864 arg1 = (NOsh *)(argp1);
04865 res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
04866 if (!SWIG_IsOK(res2)) {
04867 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NOsh_parseInputFile" "', argument " "2"" of type '" "char *""'");
04868 }
04869 arg2 = (char *)(buf2);
04870 result = (int)NOsh_parseInputFile(arg1,arg2);
04871 resultobj = SWIG_From_int((int)(result));
04872 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
04873 return resultobj;
04874 fail:
04875 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
04876 return NULL;
04877 }
04878
04879
04880 SWIGINTERN PyObject *_wrap_NOsh_ctor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04881 PyObject *resultobj = 0;
04882 int arg1 ;
04883 int arg2 ;
04884 NOsh *result = 0 ;
04885 int val1 ;
04886 int ecode1 = 0 ;
04887 int val2 ;
04888 int ecode2 = 0 ;
04889 PyObject * obj0 = 0 ;
04890 PyObject * obj1 = 0 ;
04891
04892 if (!PyArg_ParseTuple(args,(char *)"OO:NOsh_ctor",&obj0,&obj1)) SWIG_fail;
04893 ecode1 = SWIG_AsVal_int(obj0, &val1);
04894 if (!SWIG_IsOK(ecode1)) {
04895 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "NOsh_ctor" "', argument " "1"" of type '" "int""'");
04896 }
04897 arg1 = (int)(val1);
04898 ecode2 = SWIG_AsVal_int(obj1, &val2);
04899 if (!SWIG_IsOK(ecode2)) {
04900 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NOsh_ctor" "', argument " "2"" of type '" "int""'");
04901 }
04902 arg2 = (int)(val2);
04903 result = (NOsh *)NOsh_ctor(arg1,arg2);
04904 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_NOsh, 0 | 0 );
04905 return resultobj;
04906 fail:
04907 return NULL;
04908 }
04909
04910
04911 SWIGINTERN PyObject *_wrap_new_AtomForce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04912 PyObject *resultobj = 0;
04913 AtomForce *result = 0 ;
04914
04915 if (!PyArg_ParseTuple(args,(char *)":new_AtomForce")) SWIG_fail;
04916 result = (AtomForce *)(AtomForce *) calloc(1, sizeof(AtomForce));
04917 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_AtomForce, SWIG_POINTER_NEW | 0 );
04918 return resultobj;
04919 fail:
04920 return NULL;
04921 }
04922
04923
04924 SWIGINTERN PyObject *_wrap_delete_AtomForce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04925 PyObject *resultobj = 0;
04926 AtomForce *arg1 = (AtomForce *) 0 ;
04927 void *argp1 = 0 ;
04928 int res1 = 0 ;
04929 PyObject * obj0 = 0 ;
04930
04931 if (!PyArg_ParseTuple(args,(char *)"O:delete_AtomForce",&obj0)) SWIG_fail;
04932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_AtomForce, SWIG_POINTER_DISOWN | 0 );
04933 if (!SWIG_IsOK(res1)) {
04934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AtomForce" "', argument " "1"" of type '" "AtomForce *""'");
04935 }
04936 arg1 = (AtomForce *)(argp1);
04937 free((char *) arg1);
04938
04939 resultobj = SWIG_Py_Void();
04940 return resultobj;
04941 fail:
04942 return NULL;
04943 }
04944
04945
04946 SWIGINTERN PyObject *AtomForce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04947 PyObject *obj;
04948 if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
04949 SWIG_TypeNewClientData(SWIGTYPE_p_AtomForce, SWIG_NewClientData(obj));
04950 return SWIG_Py_Void();
04951 }
04952
04953 SWIGINTERN PyObject *_wrap_new_valist(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04954 PyObject *resultobj = 0;
04955 int arg1 ;
04956 Valist **result = 0 ;
04957 int val1 ;
04958 int ecode1 = 0 ;
04959 PyObject * obj0 = 0 ;
04960
04961 if (!PyArg_ParseTuple(args,(char *)"O:new_valist",&obj0)) SWIG_fail;
04962 ecode1 = SWIG_AsVal_int(obj0, &val1);
04963 if (!SWIG_IsOK(ecode1)) {
04964 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_valist" "', argument " "1"" of type '" "int""'");
04965 }
04966 arg1 = (int)(val1);
04967 result = (Valist **)new_valist(arg1);
04968 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_Valist, 0 | 0 );
04969 return resultobj;
04970 fail:
04971 return NULL;
04972 }
04973
04974
04975 SWIGINTERN PyObject *_wrap_get_Valist(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
04976 PyObject *resultobj = 0;
04977 Valist **arg1 = (Valist **) 0 ;
04978 int arg2 ;
04979 Valist *result = 0 ;
04980 void *argp1 = 0 ;
04981 int res1 = 0 ;
04982 int val2 ;
04983 int ecode2 = 0 ;
04984 PyObject * obj0 = 0 ;
04985 PyObject * obj1 = 0 ;
04986
04987 if (!PyArg_ParseTuple(args,(char *)"OO:get_Valist",&obj0,&obj1)) SWIG_fail;
04988 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_Valist, 0 | 0 );
04989 if (!SWIG_IsOK(res1)) {
04990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "get_Valist" "', argument " "1"" of type '" "Valist **""'");
04991 }
04992 arg1 = (Valist **)(argp1);
04993 ecode2 = SWIG_AsVal_int(obj1, &val2);
04994 if (!SWIG_IsOK(ecode2)) {
04995 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "get_Valist" "', argument " "2"" of type '" "int""'");
04996 }
04997 arg2 = (int)(val2);
04998 result = (Valist *)get_Valist(arg1,arg2);
04999 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Valist, 0 | 0 );
05000 return resultobj;
05001 fail:
05002 return NULL;
05003 }
05004
05005
05006 SWIGINTERN PyObject *_wrap_new_gridlist(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05007 PyObject *resultobj = 0;
05008 int arg1 ;
05009 Vgrid **result = 0 ;
05010 int val1 ;
05011 int ecode1 = 0 ;
05012 PyObject * obj0 = 0 ;
05013
05014 if (!PyArg_ParseTuple(args,(char *)"O:new_gridlist",&obj0)) SWIG_fail;
05015 ecode1 = SWIG_AsVal_int(obj0, &val1);
05016 if (!SWIG_IsOK(ecode1)) {
05017 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_gridlist" "', argument " "1"" of type '" "int""'");
05018 }
05019 arg1 = (int)(val1);
05020 result = (Vgrid **)new_gridlist(arg1);
05021 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_Vgrid, 0 | 0 );
05022 return resultobj;
05023 fail:
05024 return NULL;
05025 }
05026
05027
05028 SWIGINTERN PyObject *_wrap_new_pmglist(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05029 PyObject *resultobj = 0;
05030 int arg1 ;
05031 Vpmg **result = 0 ;
05032 int val1 ;
05033 int ecode1 = 0 ;
05034 PyObject * obj0 = 0 ;
05035
05036 if (!PyArg_ParseTuple(args,(char *)"O:new_pmglist",&obj0)) SWIG_fail;
05037 ecode1 = SWIG_AsVal_int(obj0, &val1);
05038 if (!SWIG_IsOK(ecode1)) {
05039 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_pmglist" "', argument " "1"" of type '" "int""'");
05040 }
05041 arg1 = (int)(val1);
05042 result = (Vpmg **)new_pmglist(arg1);
05043 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_Vpmg, 0 | 0 );
05044 return resultobj;
05045 fail:
05046 return NULL;
05047 }
05048
05049
05050 SWIGINTERN PyObject *_wrap_get_Vpmg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05051 PyObject *resultobj = 0;
05052 Vpmg **arg1 = (Vpmg **) 0 ;
05053 int arg2 ;
05054 Vpmg *result = 0 ;
05055 void *argp1 = 0 ;
05056 int res1 = 0 ;
05057 int val2 ;
05058 int ecode2 = 0 ;
05059 PyObject * obj0 = 0 ;
05060 PyObject * obj1 = 0 ;
05061
05062 if (!PyArg_ParseTuple(args,(char *)"OO:get_Vpmg",&obj0,&obj1)) SWIG_fail;
05063 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_Vpmg, 0 | 0 );
05064 if (!SWIG_IsOK(res1)) {
05065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "get_Vpmg" "', argument " "1"" of type '" "Vpmg **""'");
05066 }
05067 arg1 = (Vpmg **)(argp1);
05068 ecode2 = SWIG_AsVal_int(obj1, &val2);
05069 if (!SWIG_IsOK(ecode2)) {
05070 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "get_Vpmg" "', argument " "2"" of type '" "int""'");
05071 }
05072 arg2 = (int)(val2);
05073 result = (Vpmg *)get_Vpmg(arg1,arg2);
05074 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Vpmg, 0 | 0 );
05075 return resultobj;
05076 fail:
05077 return NULL;
05078 }
05079
05080
05081 SWIGINTERN PyObject *_wrap_new_pmgplist(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05082 PyObject *resultobj = 0;
05083 int arg1 ;
05084 Vpmgp **result = 0 ;
05085 int val1 ;
05086 int ecode1 = 0 ;
05087 PyObject * obj0 = 0 ;
05088
05089 if (!PyArg_ParseTuple(args,(char *)"O:new_pmgplist",&obj0)) SWIG_fail;
05090 ecode1 = SWIG_AsVal_int(obj0, &val1);
05091 if (!SWIG_IsOK(ecode1)) {
05092 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_pmgplist" "', argument " "1"" of type '" "int""'");
05093 }
05094 arg1 = (int)(val1);
05095 result = (Vpmgp **)new_pmgplist(arg1);
05096 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_Vpmgp, 0 | 0 );
05097 return resultobj;
05098 fail:
05099 return NULL;
05100 }
05101
05102
05103 SWIGINTERN PyObject *_wrap_new_pbelist(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05104 PyObject *resultobj = 0;
05105 int arg1 ;
05106 Vpbe **result = 0 ;
05107 int val1 ;
05108 int ecode1 = 0 ;
05109 PyObject * obj0 = 0 ;
05110
05111 if (!PyArg_ParseTuple(args,(char *)"O:new_pbelist",&obj0)) SWIG_fail;
05112 ecode1 = SWIG_AsVal_int(obj0, &val1);
05113 if (!SWIG_IsOK(ecode1)) {
05114 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_pbelist" "', argument " "1"" of type '" "int""'");
05115 }
05116 arg1 = (int)(val1);
05117 result = (Vpbe **)new_pbelist(arg1);
05118 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_Vpbe, 0 | 0 );
05119 return resultobj;
05120 fail:
05121 return NULL;
05122 }
05123
05124
05125 SWIGINTERN PyObject *_wrap_get_Vpbe(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05126 PyObject *resultobj = 0;
05127 Vpbe **arg1 = (Vpbe **) 0 ;
05128 int arg2 ;
05129 Vpbe *result = 0 ;
05130 void *argp1 = 0 ;
05131 int res1 = 0 ;
05132 int val2 ;
05133 int ecode2 = 0 ;
05134 PyObject * obj0 = 0 ;
05135 PyObject * obj1 = 0 ;
05136
05137 if (!PyArg_ParseTuple(args,(char *)"OO:get_Vpbe",&obj0,&obj1)) SWIG_fail;
05138 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_Vpbe, 0 | 0 );
05139 if (!SWIG_IsOK(res1)) {
05140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "get_Vpbe" "', argument " "1"" of type '" "Vpbe **""'");
05141 }
05142 arg1 = (Vpbe **)(argp1);
05143 ecode2 = SWIG_AsVal_int(obj1, &val2);
05144 if (!SWIG_IsOK(ecode2)) {
05145 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "get_Vpbe" "', argument " "2"" of type '" "int""'");
05146 }
05147 arg2 = (int)(val2);
05148 result = (Vpbe *)get_Vpbe(arg1,arg2);
05149 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Vpbe, 0 | 0 );
05150 return resultobj;
05151 fail:
05152 return NULL;
05153 }
05154
05155
05156 SWIGINTERN PyObject *_wrap_new_atomforcelist(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05157 PyObject *resultobj = 0;
05158 int arg1 ;
05159 AtomForce **result = 0 ;
05160 int val1 ;
05161 int ecode1 = 0 ;
05162 PyObject * obj0 = 0 ;
05163
05164 if (!PyArg_ParseTuple(args,(char *)"O:new_atomforcelist",&obj0)) SWIG_fail;
05165 ecode1 = SWIG_AsVal_int(obj0, &val1);
05166 if (!SWIG_IsOK(ecode1)) {
05167 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_atomforcelist" "', argument " "1"" of type '" "int""'");
05168 }
05169 arg1 = (int)(val1);
05170 result = (AtomForce **)new_atomforcelist(arg1);
05171 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_AtomForce, 0 | 0 );
05172 return resultobj;
05173 fail:
05174 return NULL;
05175 }
05176
05177
05178 SWIGINTERN PyObject *_wrap_delete_atomforcelist(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05179 PyObject *resultobj = 0;
05180 AtomForce **arg1 = (AtomForce **) 0 ;
05181 void *argp1 = 0 ;
05182 int res1 = 0 ;
05183 PyObject * obj0 = 0 ;
05184
05185 if (!PyArg_ParseTuple(args,(char *)"O:delete_atomforcelist",&obj0)) SWIG_fail;
05186 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_AtomForce, 0 | 0 );
05187 if (!SWIG_IsOK(res1)) {
05188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_atomforcelist" "', argument " "1"" of type '" "AtomForce **""'");
05189 }
05190 arg1 = (AtomForce **)(argp1);
05191 delete_atomforcelist(arg1);
05192 resultobj = SWIG_Py_Void();
05193 return resultobj;
05194 fail:
05195 return NULL;
05196 }
05197
05198
05199 SWIGINTERN PyObject *_wrap_delete_valist(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05200 PyObject *resultobj = 0;
05201 Valist **arg1 = (Valist **) 0 ;
05202 void *argp1 = 0 ;
05203 int res1 = 0 ;
05204 PyObject * obj0 = 0 ;
05205
05206 if (!PyArg_ParseTuple(args,(char *)"O:delete_valist",&obj0)) SWIG_fail;
05207 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_Valist, 0 | 0 );
05208 if (!SWIG_IsOK(res1)) {
05209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_valist" "', argument " "1"" of type '" "Valist **""'");
05210 }
05211 arg1 = (Valist **)(argp1);
05212 delete_valist(arg1);
05213 resultobj = SWIG_Py_Void();
05214 return resultobj;
05215 fail:
05216 return NULL;
05217 }
05218
05219
05220 SWIGINTERN PyObject *_wrap_delete_gridlist(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05221 PyObject *resultobj = 0;
05222 Vgrid **arg1 = (Vgrid **) 0 ;
05223 void *argp1 = 0 ;
05224 int res1 = 0 ;
05225 PyObject * obj0 = 0 ;
05226
05227 if (!PyArg_ParseTuple(args,(char *)"O:delete_gridlist",&obj0)) SWIG_fail;
05228 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_Vgrid, 0 | 0 );
05229 if (!SWIG_IsOK(res1)) {
05230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_gridlist" "', argument " "1"" of type '" "Vgrid **""'");
05231 }
05232 arg1 = (Vgrid **)(argp1);
05233 delete_gridlist(arg1);
05234 resultobj = SWIG_Py_Void();
05235 return resultobj;
05236 fail:
05237 return NULL;
05238 }
05239
05240
05241 SWIGINTERN PyObject *_wrap_delete_pmglist(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05242 PyObject *resultobj = 0;
05243 Vpmg **arg1 = (Vpmg **) 0 ;
05244 void *argp1 = 0 ;
05245 int res1 = 0 ;
05246 PyObject * obj0 = 0 ;
05247
05248 if (!PyArg_ParseTuple(args,(char *)"O:delete_pmglist",&obj0)) SWIG_fail;
05249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_Vpmg, 0 | 0 );
05250 if (!SWIG_IsOK(res1)) {
05251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pmglist" "', argument " "1"" of type '" "Vpmg **""'");
05252 }
05253 arg1 = (Vpmg **)(argp1);
05254 delete_pmglist(arg1);
05255 resultobj = SWIG_Py_Void();
05256 return resultobj;
05257 fail:
05258 return NULL;
05259 }
05260
05261
05262 SWIGINTERN PyObject *_wrap_delete_pmgplist(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05263 PyObject *resultobj = 0;
05264 Vpmgp **arg1 = (Vpmgp **) 0 ;
05265 void *argp1 = 0 ;
05266 int res1 = 0 ;
05267 PyObject * obj0 = 0 ;
05268
05269 if (!PyArg_ParseTuple(args,(char *)"O:delete_pmgplist",&obj0)) SWIG_fail;
05270 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_Vpmgp, 0 | 0 );
05271 if (!SWIG_IsOK(res1)) {
05272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pmgplist" "', argument " "1"" of type '" "Vpmgp **""'");
05273 }
05274 arg1 = (Vpmgp **)(argp1);
05275 delete_pmgplist(arg1);
05276 resultobj = SWIG_Py_Void();
05277 return resultobj;
05278 fail:
05279 return NULL;
05280 }
05281
05282
05283 SWIGINTERN PyObject *_wrap_delete_pbelist(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05284 PyObject *resultobj = 0;
05285 Vpbe **arg1 = (Vpbe **) 0 ;
05286 void *argp1 = 0 ;
05287 int res1 = 0 ;
05288 PyObject * obj0 = 0 ;
05289
05290 if (!PyArg_ParseTuple(args,(char *)"O:delete_pbelist",&obj0)) SWIG_fail;
05291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_Vpbe, 0 | 0 );
05292 if (!SWIG_IsOK(res1)) {
05293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pbelist" "', argument " "1"" of type '" "Vpbe **""'");
05294 }
05295 arg1 = (Vpbe **)(argp1);
05296 delete_pbelist(arg1);
05297 resultobj = SWIG_Py_Void();
05298 return resultobj;
05299 fail:
05300 return NULL;
05301 }
05302
05303
05304 SWIGINTERN PyObject *_wrap_delete_Nosh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05305 PyObject *resultobj = 0;
05306 NOsh *arg1 = (NOsh *) 0 ;
05307 void *argp1 = 0 ;
05308 int res1 = 0 ;
05309 PyObject * obj0 = 0 ;
05310
05311 if (!PyArg_ParseTuple(args,(char *)"O:delete_Nosh",&obj0)) SWIG_fail;
05312 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_NOsh, 0 | 0 );
05313 if (!SWIG_IsOK(res1)) {
05314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Nosh" "', argument " "1"" of type '" "NOsh *""'");
05315 }
05316 arg1 = (NOsh *)(argp1);
05317 delete_Nosh(arg1);
05318 resultobj = SWIG_Py_Void();
05319 return resultobj;
05320 fail:
05321 return NULL;
05322 }
05323
05324
05325 SWIGINTERN PyObject *_wrap_delete_Com(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05326 PyObject *resultobj = 0;
05327 Vcom *arg1 = (Vcom *) 0 ;
05328 void *argp1 = 0 ;
05329 int res1 = 0 ;
05330 PyObject * obj0 = 0 ;
05331
05332 if (!PyArg_ParseTuple(args,(char *)"O:delete_Com",&obj0)) SWIG_fail;
05333 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Vcom, 0 | 0 );
05334 if (!SWIG_IsOK(res1)) {
05335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Com" "', argument " "1"" of type '" "Vcom *""'");
05336 }
05337 arg1 = (Vcom *)(argp1);
05338 delete_Com(arg1);
05339 resultobj = SWIG_Py_Void();
05340 return resultobj;
05341 fail:
05342 return NULL;
05343 }
05344
05345
05346 SWIGINTERN PyObject *_wrap_delete_Mem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05347 PyObject *resultobj = 0;
05348 Vmem *arg1 = (Vmem *) 0 ;
05349 void *argp1 = 0 ;
05350 int res1 = 0 ;
05351 PyObject * obj0 = 0 ;
05352
05353 if (!PyArg_ParseTuple(args,(char *)"O:delete_Mem",&obj0)) SWIG_fail;
05354 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Vmem, 0 | 0 );
05355 if (!SWIG_IsOK(res1)) {
05356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Mem" "', argument " "1"" of type '" "Vmem *""'");
05357 }
05358 arg1 = (Vmem *)(argp1);
05359 delete_Mem(arg1);
05360 resultobj = SWIG_Py_Void();
05361 return resultobj;
05362 fail:
05363 return NULL;
05364 }
05365
05366
05367 SWIGINTERN PyObject *_wrap_get_AtomForce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05368 PyObject *resultobj = 0;
05369 AtomForce **arg1 = (AtomForce **) 0 ;
05370 int arg2 ;
05371 AtomForce **result = 0 ;
05372 void *argp1 = 0 ;
05373 int res1 = 0 ;
05374 int val2 ;
05375 int ecode2 = 0 ;
05376 PyObject * obj0 = 0 ;
05377 PyObject * obj1 = 0 ;
05378
05379 if (!PyArg_ParseTuple(args,(char *)"OO:get_AtomForce",&obj0,&obj1)) SWIG_fail;
05380 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_AtomForce, 0 | 0 );
05381 if (!SWIG_IsOK(res1)) {
05382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "get_AtomForce" "', argument " "1"" of type '" "AtomForce **""'");
05383 }
05384 arg1 = (AtomForce **)(argp1);
05385 ecode2 = SWIG_AsVal_int(obj1, &val2);
05386 if (!SWIG_IsOK(ecode2)) {
05387 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "get_AtomForce" "', argument " "2"" of type '" "int""'");
05388 }
05389 arg2 = (int)(val2);
05390 result = (AtomForce **)get_AtomForce(arg1,arg2);
05391 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_AtomForce, 0 | 0 );
05392 return resultobj;
05393 fail:
05394 return NULL;
05395 }
05396
05397
05398 SWIGINTERN PyObject *_wrap_make_Valist(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05399 PyObject *resultobj = 0;
05400 Valist **arg1 = (Valist **) 0 ;
05401 int arg2 ;
05402 Valist *result = 0 ;
05403 void *argp1 = 0 ;
05404 int res1 = 0 ;
05405 int val2 ;
05406 int ecode2 = 0 ;
05407 PyObject * obj0 = 0 ;
05408 PyObject * obj1 = 0 ;
05409
05410 if (!PyArg_ParseTuple(args,(char *)"OO:make_Valist",&obj0,&obj1)) SWIG_fail;
05411 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_Valist, 0 | 0 );
05412 if (!SWIG_IsOK(res1)) {
05413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "make_Valist" "', argument " "1"" of type '" "Valist **""'");
05414 }
05415 arg1 = (Valist **)(argp1);
05416 ecode2 = SWIG_AsVal_int(obj1, &val2);
05417 if (!SWIG_IsOK(ecode2)) {
05418 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "make_Valist" "', argument " "2"" of type '" "int""'");
05419 }
05420 arg2 = (int)(val2);
05421 result = (Valist *)make_Valist(arg1,arg2);
05422 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Valist, 0 | 0 );
05423 return resultobj;
05424 fail:
05425 return NULL;
05426 }
05427
05428
05429 SWIGINTERN PyObject *_wrap_remove_Valist(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05430 PyObject *resultobj = 0;
05431 Valist *arg1 = (Valist *) 0 ;
05432 void *argp1 = 0 ;
05433 int res1 = 0 ;
05434 PyObject * obj0 = 0 ;
05435
05436 if (!PyArg_ParseTuple(args,(char *)"O:remove_Valist",&obj0)) SWIG_fail;
05437 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Valist, 0 | 0 );
05438 if (!SWIG_IsOK(res1)) {
05439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "remove_Valist" "', argument " "1"" of type '" "Valist *""'");
05440 }
05441 arg1 = (Valist *)(argp1);
05442 remove_Valist(arg1);
05443 resultobj = SWIG_Py_Void();
05444 return resultobj;
05445 fail:
05446 return NULL;
05447 }
05448
05449
05450 SWIGINTERN PyObject *_wrap_double_array(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05451 PyObject *resultobj = 0;
05452 int arg1 ;
05453 double *result = 0 ;
05454 int val1 ;
05455 int ecode1 = 0 ;
05456 PyObject * obj0 = 0 ;
05457
05458 if (!PyArg_ParseTuple(args,(char *)"O:double_array",&obj0)) SWIG_fail;
05459 ecode1 = SWIG_AsVal_int(obj0, &val1);
05460 if (!SWIG_IsOK(ecode1)) {
05461 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "double_array" "', argument " "1"" of type '" "int""'");
05462 }
05463 arg1 = (int)(val1);
05464 result = (double *)double_array(arg1);
05465 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 );
05466 return resultobj;
05467 fail:
05468 return NULL;
05469 }
05470
05471
05472 SWIGINTERN PyObject *_wrap_int_array(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05473 PyObject *resultobj = 0;
05474 int arg1 ;
05475 int *result = 0 ;
05476 int val1 ;
05477 int ecode1 = 0 ;
05478 PyObject * obj0 = 0 ;
05479
05480 if (!PyArg_ParseTuple(args,(char *)"O:int_array",&obj0)) SWIG_fail;
05481 ecode1 = SWIG_AsVal_int(obj0, &val1);
05482 if (!SWIG_IsOK(ecode1)) {
05483 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "int_array" "', argument " "1"" of type '" "int""'");
05484 }
05485 arg1 = (int)(val1);
05486 result = (int *)int_array(arg1);
05487 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 );
05488 return resultobj;
05489 fail:
05490 return NULL;
05491 }
05492
05493
05494 SWIGINTERN PyObject *_wrap_delete_double_array(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05495 PyObject *resultobj = 0;
05496 double *arg1 = (double *) 0 ;
05497 void *argp1 = 0 ;
05498 int res1 = 0 ;
05499 PyObject * obj0 = 0 ;
05500
05501 if (!PyArg_ParseTuple(args,(char *)"O:delete_double_array",&obj0)) SWIG_fail;
05502 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 | 0 );
05503 if (!SWIG_IsOK(res1)) {
05504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_double_array" "', argument " "1"" of type '" "double *""'");
05505 }
05506 arg1 = (double *)(argp1);
05507 delete_double_array(arg1);
05508 resultobj = SWIG_Py_Void();
05509 return resultobj;
05510 fail:
05511 return NULL;
05512 }
05513
05514
05515 SWIGINTERN PyObject *_wrap_delete_int_array(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05516 PyObject *resultobj = 0;
05517 int *arg1 = (int *) 0 ;
05518 void *argp1 = 0 ;
05519 int res1 = 0 ;
05520 PyObject * obj0 = 0 ;
05521
05522 if (!PyArg_ParseTuple(args,(char *)"O:delete_int_array",&obj0)) SWIG_fail;
05523 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_int, 0 | 0 );
05524 if (!SWIG_IsOK(res1)) {
05525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_int_array" "', argument " "1"" of type '" "int *""'");
05526 }
05527 arg1 = (int *)(argp1);
05528 delete_int_array(arg1);
05529 resultobj = SWIG_Py_Void();
05530 return resultobj;
05531 fail:
05532 return NULL;
05533 }
05534
05535
05536 SWIGINTERN PyObject *_wrap_get_entry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05537 PyObject *resultobj = 0;
05538 double *arg1 = (double *) 0 ;
05539 int arg2 ;
05540 double result;
05541 void *argp1 = 0 ;
05542 int res1 = 0 ;
05543 int val2 ;
05544 int ecode2 = 0 ;
05545 PyObject * obj0 = 0 ;
05546 PyObject * obj1 = 0 ;
05547
05548 if (!PyArg_ParseTuple(args,(char *)"OO:get_entry",&obj0,&obj1)) SWIG_fail;
05549 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 | 0 );
05550 if (!SWIG_IsOK(res1)) {
05551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "get_entry" "', argument " "1"" of type '" "double *""'");
05552 }
05553 arg1 = (double *)(argp1);
05554 ecode2 = SWIG_AsVal_int(obj1, &val2);
05555 if (!SWIG_IsOK(ecode2)) {
05556 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "get_entry" "', argument " "2"" of type '" "int""'");
05557 }
05558 arg2 = (int)(val2);
05559 result = (double)get_entry(arg1,arg2);
05560 resultobj = SWIG_From_double((double)(result));
05561 return resultobj;
05562 fail:
05563 return NULL;
05564 }
05565
05566
05567 SWIGINTERN PyObject *_wrap_set_entry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05568 PyObject *resultobj = 0;
05569 double *arg1 = (double *) 0 ;
05570 int arg2 ;
05571 double arg3 ;
05572 void *argp1 = 0 ;
05573 int res1 = 0 ;
05574 int val2 ;
05575 int ecode2 = 0 ;
05576 double val3 ;
05577 int ecode3 = 0 ;
05578 PyObject * obj0 = 0 ;
05579 PyObject * obj1 = 0 ;
05580 PyObject * obj2 = 0 ;
05581
05582 if (!PyArg_ParseTuple(args,(char *)"OOO:set_entry",&obj0,&obj1,&obj2)) SWIG_fail;
05583 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 | 0 );
05584 if (!SWIG_IsOK(res1)) {
05585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "set_entry" "', argument " "1"" of type '" "double *""'");
05586 }
05587 arg1 = (double *)(argp1);
05588 ecode2 = SWIG_AsVal_int(obj1, &val2);
05589 if (!SWIG_IsOK(ecode2)) {
05590 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "set_entry" "', argument " "2"" of type '" "int""'");
05591 }
05592 arg2 = (int)(val2);
05593 ecode3 = SWIG_AsVal_double(obj2, &val3);
05594 if (!SWIG_IsOK(ecode3)) {
05595 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "set_entry" "', argument " "3"" of type '" "double""'");
05596 }
05597 arg3 = (double)(val3);
05598 set_entry(arg1,arg2,arg3);
05599 resultobj = SWIG_Py_Void();
05600 return resultobj;
05601 fail:
05602 return NULL;
05603 }
05604
05605
05606 SWIGINTERN PyObject *_wrap_parseInputFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05607 PyObject *resultobj = 0;
05608 NOsh *arg1 = (NOsh *) 0 ;
05609 PyObject *arg2 = (PyObject *) 0 ;
05610 int result;
05611 void *argp1 = 0 ;
05612 int res1 = 0 ;
05613 PyObject * obj0 = 0 ;
05614 PyObject * obj1 = 0 ;
05615
05616 if (!PyArg_ParseTuple(args,(char *)"OO:parseInputFromString",&obj0,&obj1)) SWIG_fail;
05617 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_NOsh, 0 | 0 );
05618 if (!SWIG_IsOK(res1)) {
05619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "parseInputFromString" "', argument " "1"" of type '" "NOsh *""'");
05620 }
05621 arg1 = (NOsh *)(argp1);
05622 arg2 = obj1;
05623 result = (int)parseInputFromString(arg1,arg2);
05624 resultobj = SWIG_From_int((int)(result));
05625 return resultobj;
05626 fail:
05627 return NULL;
05628 }
05629
05630
05631 SWIGINTERN PyObject *_wrap_Valist_load(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05632 PyObject *resultobj = 0;
05633 Valist *arg1 = (Valist *) 0 ;
05634 int arg2 ;
05635 PyObject *arg3 = (PyObject *) 0 ;
05636 PyObject *arg4 = (PyObject *) 0 ;
05637 PyObject *arg5 = (PyObject *) 0 ;
05638 PyObject *arg6 = (PyObject *) 0 ;
05639 PyObject *arg7 = (PyObject *) 0 ;
05640 void *argp1 = 0 ;
05641 int res1 = 0 ;
05642 int val2 ;
05643 int ecode2 = 0 ;
05644 PyObject * obj0 = 0 ;
05645 PyObject * obj1 = 0 ;
05646 PyObject * obj2 = 0 ;
05647 PyObject * obj3 = 0 ;
05648 PyObject * obj4 = 0 ;
05649 PyObject * obj5 = 0 ;
05650 PyObject * obj6 = 0 ;
05651
05652 if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Valist_load",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
05653 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Valist, 0 | 0 );
05654 if (!SWIG_IsOK(res1)) {
05655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Valist_load" "', argument " "1"" of type '" "Valist *""'");
05656 }
05657 arg1 = (Valist *)(argp1);
05658 ecode2 = SWIG_AsVal_int(obj1, &val2);
05659 if (!SWIG_IsOK(ecode2)) {
05660 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Valist_load" "', argument " "2"" of type '" "int""'");
05661 }
05662 arg2 = (int)(val2);
05663 arg3 = obj2;
05664 arg4 = obj3;
05665 arg5 = obj4;
05666 arg6 = obj5;
05667 arg7 = obj6;
05668 Valist_load(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
05669 resultobj = SWIG_Py_Void();
05670 return resultobj;
05671 fail:
05672 return NULL;
05673 }
05674
05675
05676 SWIGINTERN PyObject *_wrap_NOsh_setupElecCalc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05677 PyObject *resultobj = 0;
05678 NOsh *arg1 = (NOsh *) 0 ;
05679 Valist **arg2 ;
05680 int result;
05681 void *argp1 = 0 ;
05682 int res1 = 0 ;
05683 void *argp2 = 0 ;
05684 int res2 = 0 ;
05685 PyObject * obj0 = 0 ;
05686 PyObject * obj1 = 0 ;
05687
05688 if (!PyArg_ParseTuple(args,(char *)"OO:NOsh_setupElecCalc",&obj0,&obj1)) SWIG_fail;
05689 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_NOsh, 0 | 0 );
05690 if (!SWIG_IsOK(res1)) {
05691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NOsh_setupElecCalc" "', argument " "1"" of type '" "NOsh *""'");
05692 }
05693 arg1 = (NOsh *)(argp1);
05694 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_Valist, 0 | 0 );
05695 if (!SWIG_IsOK(res2)) {
05696 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NOsh_setupElecCalc" "', argument " "2"" of type '" "Valist *[NOSH_MAXMOL]""'");
05697 }
05698 arg2 = (Valist **)(argp2);
05699 result = (int)NOsh_setupElecCalc(arg1,arg2);
05700 resultobj = SWIG_From_int((int)(result));
05701 return resultobj;
05702 fail:
05703 return NULL;
05704 }
05705
05706
05707 SWIGINTERN PyObject *_wrap_NOsh_setupApolCalc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05708 PyObject *resultobj = 0;
05709 NOsh *arg1 = (NOsh *) 0 ;
05710 Valist **arg2 ;
05711 int result;
05712 void *argp1 = 0 ;
05713 int res1 = 0 ;
05714 void *argp2 = 0 ;
05715 int res2 = 0 ;
05716 PyObject * obj0 = 0 ;
05717 PyObject * obj1 = 0 ;
05718
05719 if (!PyArg_ParseTuple(args,(char *)"OO:NOsh_setupApolCalc",&obj0,&obj1)) SWIG_fail;
05720 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_NOsh, 0 | 0 );
05721 if (!SWIG_IsOK(res1)) {
05722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NOsh_setupApolCalc" "', argument " "1"" of type '" "NOsh *""'");
05723 }
05724 arg1 = (NOsh *)(argp1);
05725 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_Valist, 0 | 0 );
05726 if (!SWIG_IsOK(res2)) {
05727 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NOsh_setupApolCalc" "', argument " "2"" of type '" "Valist *[NOSH_MAXMOL]""'");
05728 }
05729 arg2 = (Valist **)(argp2);
05730 result = (int)NOsh_setupApolCalc(arg1,arg2);
05731 resultobj = SWIG_From_int((int)(result));
05732 return resultobj;
05733 fail:
05734 return NULL;
05735 }
05736
05737
05738 SWIGINTERN PyObject *_wrap_wrap_forceMG(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05739 PyObject *resultobj = 0;
05740 Vmem *arg1 = (Vmem *) 0 ;
05741 NOsh *arg2 = (NOsh *) 0 ;
05742 PBEparm *arg3 = (PBEparm *) 0 ;
05743 MGparm *arg4 = (MGparm *) 0 ;
05744 Vpmg *arg5 = (Vpmg *) 0 ;
05745 AtomForce **arg6 ;
05746 Valist **arg7 ;
05747 int *arg8 ;
05748 int arg9 ;
05749 int result;
05750 void *argp1 = 0 ;
05751 int res1 = 0 ;
05752 void *argp2 = 0 ;
05753 int res2 = 0 ;
05754 void *argp3 = 0 ;
05755 int res3 = 0 ;
05756 void *argp4 = 0 ;
05757 int res4 = 0 ;
05758 void *argp5 = 0 ;
05759 int res5 = 0 ;
05760 void *argp6 = 0 ;
05761 int res6 = 0 ;
05762 void *argp7 = 0 ;
05763 int res7 = 0 ;
05764 void *argp8 = 0 ;
05765 int res8 = 0 ;
05766 int val9 ;
05767 int ecode9 = 0 ;
05768 PyObject * obj0 = 0 ;
05769 PyObject * obj1 = 0 ;
05770 PyObject * obj2 = 0 ;
05771 PyObject * obj3 = 0 ;
05772 PyObject * obj4 = 0 ;
05773 PyObject * obj5 = 0 ;
05774 PyObject * obj6 = 0 ;
05775 PyObject * obj7 = 0 ;
05776 PyObject * obj8 = 0 ;
05777
05778 if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:wrap_forceMG",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
05779 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Vmem, 0 | 0 );
05780 if (!SWIG_IsOK(res1)) {
05781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "wrap_forceMG" "', argument " "1"" of type '" "Vmem *""'");
05782 }
05783 arg1 = (Vmem *)(argp1);
05784 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_NOsh, 0 | 0 );
05785 if (!SWIG_IsOK(res2)) {
05786 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "wrap_forceMG" "', argument " "2"" of type '" "NOsh *""'");
05787 }
05788 arg2 = (NOsh *)(argp2);
05789 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_PBEparm, 0 | 0 );
05790 if (!SWIG_IsOK(res3)) {
05791 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "wrap_forceMG" "', argument " "3"" of type '" "PBEparm *""'");
05792 }
05793 arg3 = (PBEparm *)(argp3);
05794 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_MGparm, 0 | 0 );
05795 if (!SWIG_IsOK(res4)) {
05796 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "wrap_forceMG" "', argument " "4"" of type '" "MGparm *""'");
05797 }
05798 arg4 = (MGparm *)(argp4);
05799 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_Vpmg, 0 | 0 );
05800 if (!SWIG_IsOK(res5)) {
05801 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "wrap_forceMG" "', argument " "5"" of type '" "Vpmg *""'");
05802 }
05803 arg5 = (Vpmg *)(argp5);
05804 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_p_AtomForce, 0 | 0 );
05805 if (!SWIG_IsOK(res6)) {
05806 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "wrap_forceMG" "', argument " "6"" of type '" "AtomForce *[NOSH_MAXCALC]""'");
05807 }
05808 arg6 = (AtomForce **)(argp6);
05809 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_p_Valist, 0 | 0 );
05810 if (!SWIG_IsOK(res7)) {
05811 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "wrap_forceMG" "', argument " "7"" of type '" "Valist *[NOSH_MAXMOL]""'");
05812 }
05813 arg7 = (Valist **)(argp7);
05814 res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_int, 0 | 0 );
05815 if (!SWIG_IsOK(res8)) {
05816 SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "wrap_forceMG" "', argument " "8"" of type '" "int [NOSH_MAXCALC]""'");
05817 }
05818 arg8 = (int *)(argp8);
05819 ecode9 = SWIG_AsVal_int(obj8, &val9);
05820 if (!SWIG_IsOK(ecode9)) {
05821 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "wrap_forceMG" "', argument " "9"" of type '" "int""'");
05822 }
05823 arg9 = (int)(val9);
05824 result = (int)wrap_forceMG(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
05825 resultobj = SWIG_From_int((int)(result));
05826 return resultobj;
05827 fail:
05828 return NULL;
05829 }
05830
05831
05832 SWIGINTERN PyObject *_wrap_getAtomPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05833 PyObject *resultobj = 0;
05834 Vatom *arg1 = (Vatom *) 0 ;
05835 PyObject *result = 0 ;
05836 void *argp1 = 0 ;
05837 int res1 = 0 ;
05838 PyObject * obj0 = 0 ;
05839
05840 if (!PyArg_ParseTuple(args,(char *)"O:getAtomPosition",&obj0)) SWIG_fail;
05841 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Vatom, 0 | 0 );
05842 if (!SWIG_IsOK(res1)) {
05843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "getAtomPosition" "', argument " "1"" of type '" "Vatom *""'");
05844 }
05845 arg1 = (Vatom *)(argp1);
05846 result = (PyObject *)getAtomPosition(arg1);
05847 resultobj = result;
05848 return resultobj;
05849 fail:
05850 return NULL;
05851 }
05852
05853
05854 SWIGINTERN PyObject *_wrap_getPotentials(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05855 PyObject *resultobj = 0;
05856 NOsh *arg1 = (NOsh *) 0 ;
05857 PBEparm *arg2 = (PBEparm *) 0 ;
05858 Vpmg *arg3 = (Vpmg *) 0 ;
05859 Valist *arg4 = (Valist *) 0 ;
05860 PyObject *result = 0 ;
05861 void *argp1 = 0 ;
05862 int res1 = 0 ;
05863 void *argp2 = 0 ;
05864 int res2 = 0 ;
05865 void *argp3 = 0 ;
05866 int res3 = 0 ;
05867 void *argp4 = 0 ;
05868 int res4 = 0 ;
05869 PyObject * obj0 = 0 ;
05870 PyObject * obj1 = 0 ;
05871 PyObject * obj2 = 0 ;
05872 PyObject * obj3 = 0 ;
05873
05874 if (!PyArg_ParseTuple(args,(char *)"OOOO:getPotentials",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
05875 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_NOsh, 0 | 0 );
05876 if (!SWIG_IsOK(res1)) {
05877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "getPotentials" "', argument " "1"" of type '" "NOsh *""'");
05878 }
05879 arg1 = (NOsh *)(argp1);
05880 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_PBEparm, 0 | 0 );
05881 if (!SWIG_IsOK(res2)) {
05882 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "getPotentials" "', argument " "2"" of type '" "PBEparm *""'");
05883 }
05884 arg2 = (PBEparm *)(argp2);
05885 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Vpmg, 0 | 0 );
05886 if (!SWIG_IsOK(res3)) {
05887 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "getPotentials" "', argument " "3"" of type '" "Vpmg *""'");
05888 }
05889 arg3 = (Vpmg *)(argp3);
05890 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Valist, 0 | 0 );
05891 if (!SWIG_IsOK(res4)) {
05892 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "getPotentials" "', argument " "4"" of type '" "Valist *""'");
05893 }
05894 arg4 = (Valist *)(argp4);
05895 result = (PyObject *)getPotentials(arg1,arg2,arg3,arg4);
05896 resultobj = result;
05897 return resultobj;
05898 fail:
05899 return NULL;
05900 }
05901
05902
05903 SWIGINTERN PyObject *_wrap_getEnergies(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05904 PyObject *resultobj = 0;
05905 Vpmg *arg1 = (Vpmg *) 0 ;
05906 Valist *arg2 = (Valist *) 0 ;
05907 PyObject *result = 0 ;
05908 void *argp1 = 0 ;
05909 int res1 = 0 ;
05910 void *argp2 = 0 ;
05911 int res2 = 0 ;
05912 PyObject * obj0 = 0 ;
05913 PyObject * obj1 = 0 ;
05914
05915 if (!PyArg_ParseTuple(args,(char *)"OO:getEnergies",&obj0,&obj1)) SWIG_fail;
05916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Vpmg, 0 | 0 );
05917 if (!SWIG_IsOK(res1)) {
05918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "getEnergies" "', argument " "1"" of type '" "Vpmg *""'");
05919 }
05920 arg1 = (Vpmg *)(argp1);
05921 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Valist, 0 | 0 );
05922 if (!SWIG_IsOK(res2)) {
05923 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "getEnergies" "', argument " "2"" of type '" "Valist *""'");
05924 }
05925 arg2 = (Valist *)(argp2);
05926 result = (PyObject *)getEnergies(arg1,arg2);
05927 resultobj = result;
05928 return resultobj;
05929 fail:
05930 return NULL;
05931 }
05932
05933
05934 SWIGINTERN PyObject *_wrap_getForces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05935 PyObject *resultobj = 0;
05936 AtomForce **arg1 = (AtomForce **) 0 ;
05937 Valist *arg2 = (Valist *) 0 ;
05938 PyObject *result = 0 ;
05939 void *argp1 = 0 ;
05940 int res1 = 0 ;
05941 void *argp2 = 0 ;
05942 int res2 = 0 ;
05943 PyObject * obj0 = 0 ;
05944 PyObject * obj1 = 0 ;
05945
05946 if (!PyArg_ParseTuple(args,(char *)"OO:getForces",&obj0,&obj1)) SWIG_fail;
05947 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_AtomForce, 0 | 0 );
05948 if (!SWIG_IsOK(res1)) {
05949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "getForces" "', argument " "1"" of type '" "AtomForce **""'");
05950 }
05951 arg1 = (AtomForce **)(argp1);
05952 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Valist, 0 | 0 );
05953 if (!SWIG_IsOK(res2)) {
05954 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "getForces" "', argument " "2"" of type '" "Valist *""'");
05955 }
05956 arg2 = (Valist *)(argp2);
05957 result = (PyObject *)getForces(arg1,arg2);
05958 resultobj = result;
05959 return resultobj;
05960 fail:
05961 return NULL;
05962 }
05963
05964
05965 SWIGINTERN PyObject *_wrap_loadMolecules(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
05966 PyObject *resultobj = 0;
05967 NOsh *arg1 = (NOsh *) 0 ;
05968 Vparam *arg2 = (Vparam *) 0 ;
05969 Valist **arg3 ;
05970 int result;
05971 void *argp1 = 0 ;
05972 int res1 = 0 ;
05973 void *argp2 = 0 ;
05974 int res2 = 0 ;
05975 void *argp3 = 0 ;
05976 int res3 = 0 ;
05977 PyObject * obj0 = 0 ;
05978 PyObject * obj1 = 0 ;
05979 PyObject * obj2 = 0 ;
05980
05981 if (!PyArg_ParseTuple(args,(char *)"OOO:loadMolecules",&obj0,&obj1,&obj2)) SWIG_fail;
05982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_NOsh, 0 | 0 );
05983 if (!SWIG_IsOK(res1)) {
05984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "loadMolecules" "', argument " "1"" of type '" "NOsh *""'");
05985 }
05986 arg1 = (NOsh *)(argp1);
05987 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Vparam, 0 | 0 );
05988 if (!SWIG_IsOK(res2)) {
05989 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "loadMolecules" "', argument " "2"" of type '" "Vparam *""'");
05990 }
05991 arg2 = (Vparam *)(argp2);
05992 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_p_Valist, 0 | 0 );
05993 if (!SWIG_IsOK(res3)) {
05994 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "loadMolecules" "', argument " "3"" of type '" "Valist *[NOSH_MAXMOL]""'");
05995 }
05996 arg3 = (Valist **)(argp3);
05997 result = (int)loadMolecules(arg1,arg2,arg3);
05998 resultobj = SWIG_From_int((int)(result));
05999 return resultobj;
06000 fail:
06001 return NULL;
06002 }
06003
06004
06005 SWIGINTERN PyObject *_wrap_killMolecules(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06006 PyObject *resultobj = 0;
06007 NOsh *arg1 = (NOsh *) 0 ;
06008 Valist **arg2 ;
06009 void *argp1 = 0 ;
06010 int res1 = 0 ;
06011 void *argp2 = 0 ;
06012 int res2 = 0 ;
06013 PyObject * obj0 = 0 ;
06014 PyObject * obj1 = 0 ;
06015
06016 if (!PyArg_ParseTuple(args,(char *)"OO:killMolecules",&obj0,&obj1)) SWIG_fail;
06017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_NOsh, 0 | 0 );
06018 if (!SWIG_IsOK(res1)) {
06019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "killMolecules" "', argument " "1"" of type '" "NOsh *""'");
06020 }
06021 arg1 = (NOsh *)(argp1);
06022 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_Valist, 0 | 0 );
06023 if (!SWIG_IsOK(res2)) {
06024 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "killMolecules" "', argument " "2"" of type '" "Valist *[NOSH_MAXMOL]""'");
06025 }
06026 arg2 = (Valist **)(argp2);
06027 killMolecules(arg1,arg2);
06028 resultobj = SWIG_Py_Void();
06029 return resultobj;
06030 fail:
06031 return NULL;
06032 }
06033
06034
06035 SWIGINTERN PyObject *_wrap_loadDielMaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06036 PyObject *resultobj = 0;
06037 NOsh *arg1 = (NOsh *) 0 ;
06038 Vgrid **arg2 ;
06039 Vgrid **arg3 ;
06040 Vgrid **arg4 ;
06041 int result;
06042 void *argp1 = 0 ;
06043 int res1 = 0 ;
06044 void *argp2 = 0 ;
06045 int res2 = 0 ;
06046 void *argp3 = 0 ;
06047 int res3 = 0 ;
06048 void *argp4 = 0 ;
06049 int res4 = 0 ;
06050 PyObject * obj0 = 0 ;
06051 PyObject * obj1 = 0 ;
06052 PyObject * obj2 = 0 ;
06053 PyObject * obj3 = 0 ;
06054
06055 if (!PyArg_ParseTuple(args,(char *)"OOOO:loadDielMaps",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
06056 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_NOsh, 0 | 0 );
06057 if (!SWIG_IsOK(res1)) {
06058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "loadDielMaps" "', argument " "1"" of type '" "NOsh *""'");
06059 }
06060 arg1 = (NOsh *)(argp1);
06061 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_Vgrid, 0 | 0 );
06062 if (!SWIG_IsOK(res2)) {
06063 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "loadDielMaps" "', argument " "2"" of type '" "Vgrid *[NOSH_MAXMOL]""'");
06064 }
06065 arg2 = (Vgrid **)(argp2);
06066 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_p_Vgrid, 0 | 0 );
06067 if (!SWIG_IsOK(res3)) {
06068 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "loadDielMaps" "', argument " "3"" of type '" "Vgrid *[NOSH_MAXMOL]""'");
06069 }
06070 arg3 = (Vgrid **)(argp3);
06071 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_p_Vgrid, 0 | 0 );
06072 if (!SWIG_IsOK(res4)) {
06073 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "loadDielMaps" "', argument " "4"" of type '" "Vgrid *[NOSH_MAXMOL]""'");
06074 }
06075 arg4 = (Vgrid **)(argp4);
06076 result = (int)loadDielMaps(arg1,arg2,arg3,arg4);
06077 resultobj = SWIG_From_int((int)(result));
06078 return resultobj;
06079 fail:
06080 return NULL;
06081 }
06082
06083
06084 SWIGINTERN PyObject *_wrap_killDielMaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06085 PyObject *resultobj = 0;
06086 NOsh *arg1 = (NOsh *) 0 ;
06087 Vgrid **arg2 ;
06088 Vgrid **arg3 ;
06089 Vgrid **arg4 ;
06090 void *argp1 = 0 ;
06091 int res1 = 0 ;
06092 void *argp2 = 0 ;
06093 int res2 = 0 ;
06094 void *argp3 = 0 ;
06095 int res3 = 0 ;
06096 void *argp4 = 0 ;
06097 int res4 = 0 ;
06098 PyObject * obj0 = 0 ;
06099 PyObject * obj1 = 0 ;
06100 PyObject * obj2 = 0 ;
06101 PyObject * obj3 = 0 ;
06102
06103 if (!PyArg_ParseTuple(args,(char *)"OOOO:killDielMaps",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
06104 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_NOsh, 0 | 0 );
06105 if (!SWIG_IsOK(res1)) {
06106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "killDielMaps" "', argument " "1"" of type '" "NOsh *""'");
06107 }
06108 arg1 = (NOsh *)(argp1);
06109 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_Vgrid, 0 | 0 );
06110 if (!SWIG_IsOK(res2)) {
06111 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "killDielMaps" "', argument " "2"" of type '" "Vgrid *[NOSH_MAXMOL]""'");
06112 }
06113 arg2 = (Vgrid **)(argp2);
06114 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_p_Vgrid, 0 | 0 );
06115 if (!SWIG_IsOK(res3)) {
06116 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "killDielMaps" "', argument " "3"" of type '" "Vgrid *[NOSH_MAXMOL]""'");
06117 }
06118 arg3 = (Vgrid **)(argp3);
06119 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_p_Vgrid, 0 | 0 );
06120 if (!SWIG_IsOK(res4)) {
06121 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "killDielMaps" "', argument " "4"" of type '" "Vgrid *[NOSH_MAXMOL]""'");
06122 }
06123 arg4 = (Vgrid **)(argp4);
06124 killDielMaps(arg1,arg2,arg3,arg4);
06125 resultobj = SWIG_Py_Void();
06126 return resultobj;
06127 fail:
06128 return NULL;
06129 }
06130
06131
06132 SWIGINTERN PyObject *_wrap_loadKappaMaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06133 PyObject *resultobj = 0;
06134 NOsh *arg1 = (NOsh *) 0 ;
06135 Vgrid **arg2 ;
06136 int result;
06137 void *argp1 = 0 ;
06138 int res1 = 0 ;
06139 void *argp2 = 0 ;
06140 int res2 = 0 ;
06141 PyObject * obj0 = 0 ;
06142 PyObject * obj1 = 0 ;
06143
06144 if (!PyArg_ParseTuple(args,(char *)"OO:loadKappaMaps",&obj0,&obj1)) SWIG_fail;
06145 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_NOsh, 0 | 0 );
06146 if (!SWIG_IsOK(res1)) {
06147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "loadKappaMaps" "', argument " "1"" of type '" "NOsh *""'");
06148 }
06149 arg1 = (NOsh *)(argp1);
06150 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_Vgrid, 0 | 0 );
06151 if (!SWIG_IsOK(res2)) {
06152 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "loadKappaMaps" "', argument " "2"" of type '" "Vgrid *[NOSH_MAXMOL]""'");
06153 }
06154 arg2 = (Vgrid **)(argp2);
06155 result = (int)loadKappaMaps(arg1,arg2);
06156 resultobj = SWIG_From_int((int)(result));
06157 return resultobj;
06158 fail:
06159 return NULL;
06160 }
06161
06162
06163 SWIGINTERN PyObject *_wrap_killKappaMaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06164 PyObject *resultobj = 0;
06165 NOsh *arg1 = (NOsh *) 0 ;
06166 Vgrid **arg2 ;
06167 void *argp1 = 0 ;
06168 int res1 = 0 ;
06169 void *argp2 = 0 ;
06170 int res2 = 0 ;
06171 PyObject * obj0 = 0 ;
06172 PyObject * obj1 = 0 ;
06173
06174 if (!PyArg_ParseTuple(args,(char *)"OO:killKappaMaps",&obj0,&obj1)) SWIG_fail;
06175 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_NOsh, 0 | 0 );
06176 if (!SWIG_IsOK(res1)) {
06177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "killKappaMaps" "', argument " "1"" of type '" "NOsh *""'");
06178 }
06179 arg1 = (NOsh *)(argp1);
06180 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_Vgrid, 0 | 0 );
06181 if (!SWIG_IsOK(res2)) {
06182 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "killKappaMaps" "', argument " "2"" of type '" "Vgrid *[NOSH_MAXMOL]""'");
06183 }
06184 arg2 = (Vgrid **)(argp2);
06185 killKappaMaps(arg1,arg2);
06186 resultobj = SWIG_Py_Void();
06187 return resultobj;
06188 fail:
06189 return NULL;
06190 }
06191
06192
06193 SWIGINTERN PyObject *_wrap_loadPotMaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06194 PyObject *resultobj = 0;
06195 NOsh *arg1 = (NOsh *) 0 ;
06196 Vgrid **arg2 ;
06197 int result;
06198 void *argp1 = 0 ;
06199 int res1 = 0 ;
06200 void *argp2 = 0 ;
06201 int res2 = 0 ;
06202 PyObject * obj0 = 0 ;
06203 PyObject * obj1 = 0 ;
06204
06205 if (!PyArg_ParseTuple(args,(char *)"OO:loadPotMaps",&obj0,&obj1)) SWIG_fail;
06206 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_NOsh, 0 | 0 );
06207 if (!SWIG_IsOK(res1)) {
06208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "loadPotMaps" "', argument " "1"" of type '" "NOsh *""'");
06209 }
06210 arg1 = (NOsh *)(argp1);
06211 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_Vgrid, 0 | 0 );
06212 if (!SWIG_IsOK(res2)) {
06213 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "loadPotMaps" "', argument " "2"" of type '" "Vgrid *[NOSH_MAXMOL]""'");
06214 }
06215 arg2 = (Vgrid **)(argp2);
06216 result = (int)loadPotMaps(arg1,arg2);
06217 resultobj = SWIG_From_int((int)(result));
06218 return resultobj;
06219 fail:
06220 return NULL;
06221 }
06222
06223
06224 SWIGINTERN PyObject *_wrap_killPotMaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06225 PyObject *resultobj = 0;
06226 NOsh *arg1 = (NOsh *) 0 ;
06227 Vgrid **arg2 ;
06228 void *argp1 = 0 ;
06229 int res1 = 0 ;
06230 void *argp2 = 0 ;
06231 int res2 = 0 ;
06232 PyObject * obj0 = 0 ;
06233 PyObject * obj1 = 0 ;
06234
06235 if (!PyArg_ParseTuple(args,(char *)"OO:killPotMaps",&obj0,&obj1)) SWIG_fail;
06236 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_NOsh, 0 | 0 );
06237 if (!SWIG_IsOK(res1)) {
06238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "killPotMaps" "', argument " "1"" of type '" "NOsh *""'");
06239 }
06240 arg1 = (NOsh *)(argp1);
06241 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_Vgrid, 0 | 0 );
06242 if (!SWIG_IsOK(res2)) {
06243 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "killPotMaps" "', argument " "2"" of type '" "Vgrid *[NOSH_MAXMOL]""'");
06244 }
06245 arg2 = (Vgrid **)(argp2);
06246 killPotMaps(arg1,arg2);
06247 resultobj = SWIG_Py_Void();
06248 return resultobj;
06249 fail:
06250 return NULL;
06251 }
06252
06253
06254 SWIGINTERN PyObject *_wrap_loadChargeMaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06255 PyObject *resultobj = 0;
06256 NOsh *arg1 = (NOsh *) 0 ;
06257 Vgrid **arg2 ;
06258 int result;
06259 void *argp1 = 0 ;
06260 int res1 = 0 ;
06261 void *argp2 = 0 ;
06262 int res2 = 0 ;
06263 PyObject * obj0 = 0 ;
06264 PyObject * obj1 = 0 ;
06265
06266 if (!PyArg_ParseTuple(args,(char *)"OO:loadChargeMaps",&obj0,&obj1)) SWIG_fail;
06267 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_NOsh, 0 | 0 );
06268 if (!SWIG_IsOK(res1)) {
06269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "loadChargeMaps" "', argument " "1"" of type '" "NOsh *""'");
06270 }
06271 arg1 = (NOsh *)(argp1);
06272 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_Vgrid, 0 | 0 );
06273 if (!SWIG_IsOK(res2)) {
06274 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "loadChargeMaps" "', argument " "2"" of type '" "Vgrid *[NOSH_MAXMOL]""'");
06275 }
06276 arg2 = (Vgrid **)(argp2);
06277 result = (int)loadChargeMaps(arg1,arg2);
06278 resultobj = SWIG_From_int((int)(result));
06279 return resultobj;
06280 fail:
06281 return NULL;
06282 }
06283
06284
06285 SWIGINTERN PyObject *_wrap_killChargeMaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06286 PyObject *resultobj = 0;
06287 NOsh *arg1 = (NOsh *) 0 ;
06288 Vgrid **arg2 ;
06289 void *argp1 = 0 ;
06290 int res1 = 0 ;
06291 void *argp2 = 0 ;
06292 int res2 = 0 ;
06293 PyObject * obj0 = 0 ;
06294 PyObject * obj1 = 0 ;
06295
06296 if (!PyArg_ParseTuple(args,(char *)"OO:killChargeMaps",&obj0,&obj1)) SWIG_fail;
06297 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_NOsh, 0 | 0 );
06298 if (!SWIG_IsOK(res1)) {
06299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "killChargeMaps" "', argument " "1"" of type '" "NOsh *""'");
06300 }
06301 arg1 = (NOsh *)(argp1);
06302 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_Vgrid, 0 | 0 );
06303 if (!SWIG_IsOK(res2)) {
06304 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "killChargeMaps" "', argument " "2"" of type '" "Vgrid *[NOSH_MAXMOL]""'");
06305 }
06306 arg2 = (Vgrid **)(argp2);
06307 killChargeMaps(arg1,arg2);
06308 resultobj = SWIG_Py_Void();
06309 return resultobj;
06310 fail:
06311 return NULL;
06312 }
06313
06314
06315 SWIGINTERN PyObject *_wrap_printPBEPARM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06316 PyObject *resultobj = 0;
06317 PBEparm *arg1 = (PBEparm *) 0 ;
06318 void *argp1 = 0 ;
06319 int res1 = 0 ;
06320 PyObject * obj0 = 0 ;
06321
06322 if (!PyArg_ParseTuple(args,(char *)"O:printPBEPARM",&obj0)) SWIG_fail;
06323 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PBEparm, 0 | 0 );
06324 if (!SWIG_IsOK(res1)) {
06325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "printPBEPARM" "', argument " "1"" of type '" "PBEparm *""'");
06326 }
06327 arg1 = (PBEparm *)(argp1);
06328 printPBEPARM(arg1);
06329 resultobj = SWIG_Py_Void();
06330 return resultobj;
06331 fail:
06332 return NULL;
06333 }
06334
06335
06336 SWIGINTERN PyObject *_wrap_printMGPARM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06337 PyObject *resultobj = 0;
06338 MGparm *arg1 = (MGparm *) 0 ;
06339 double *arg2 ;
06340 void *argp1 = 0 ;
06341 int res1 = 0 ;
06342 void *argp2 = 0 ;
06343 int res2 = 0 ;
06344 PyObject * obj0 = 0 ;
06345 PyObject * obj1 = 0 ;
06346
06347 if (!PyArg_ParseTuple(args,(char *)"OO:printMGPARM",&obj0,&obj1)) SWIG_fail;
06348 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_MGparm, 0 | 0 );
06349 if (!SWIG_IsOK(res1)) {
06350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "printMGPARM" "', argument " "1"" of type '" "MGparm *""'");
06351 }
06352 arg1 = (MGparm *)(argp1);
06353 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 );
06354 if (!SWIG_IsOK(res2)) {
06355 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "printMGPARM" "', argument " "2"" of type '" "double [3]""'");
06356 }
06357 arg2 = (double *)(argp2);
06358 printMGPARM(arg1,arg2);
06359 resultobj = SWIG_Py_Void();
06360 return resultobj;
06361 fail:
06362 return NULL;
06363 }
06364
06365
06366 SWIGINTERN PyObject *_wrap_initMG(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06367 PyObject *resultobj = 0;
06368 int arg1 ;
06369 NOsh *arg2 = (NOsh *) 0 ;
06370 MGparm *arg3 = (MGparm *) 0 ;
06371 PBEparm *arg4 = (PBEparm *) 0 ;
06372 double *arg5 ;
06373 Vpbe **arg6 ;
06374 Valist **arg7 ;
06375 Vgrid **arg8 ;
06376 Vgrid **arg9 ;
06377 Vgrid **arg10 ;
06378 Vgrid **arg11 ;
06379 Vgrid **arg12 ;
06380 Vpmgp **arg13 ;
06381 Vpmg **arg14 ;
06382 Vgrid **arg15 ;
06383 int result;
06384 int val1 ;
06385 int ecode1 = 0 ;
06386 void *argp2 = 0 ;
06387 int res2 = 0 ;
06388 void *argp3 = 0 ;
06389 int res3 = 0 ;
06390 void *argp4 = 0 ;
06391 int res4 = 0 ;
06392 void *argp5 = 0 ;
06393 int res5 = 0 ;
06394 void *argp6 = 0 ;
06395 int res6 = 0 ;
06396 void *argp7 = 0 ;
06397 int res7 = 0 ;
06398 void *argp8 = 0 ;
06399 int res8 = 0 ;
06400 void *argp9 = 0 ;
06401 int res9 = 0 ;
06402 void *argp10 = 0 ;
06403 int res10 = 0 ;
06404 void *argp11 = 0 ;
06405 int res11 = 0 ;
06406 void *argp12 = 0 ;
06407 int res12 = 0 ;
06408 void *argp13 = 0 ;
06409 int res13 = 0 ;
06410 void *argp14 = 0 ;
06411 int res14 = 0 ;
06412 void *argp15 = 0 ;
06413 int res15 = 0 ;
06414 PyObject * obj0 = 0 ;
06415 PyObject * obj1 = 0 ;
06416 PyObject * obj2 = 0 ;
06417 PyObject * obj3 = 0 ;
06418 PyObject * obj4 = 0 ;
06419 PyObject * obj5 = 0 ;
06420 PyObject * obj6 = 0 ;
06421 PyObject * obj7 = 0 ;
06422 PyObject * obj8 = 0 ;
06423 PyObject * obj9 = 0 ;
06424 PyObject * obj10 = 0 ;
06425 PyObject * obj11 = 0 ;
06426 PyObject * obj12 = 0 ;
06427 PyObject * obj13 = 0 ;
06428 PyObject * obj14 = 0 ;
06429
06430 if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOO:initMG",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14)) SWIG_fail;
06431 ecode1 = SWIG_AsVal_int(obj0, &val1);
06432 if (!SWIG_IsOK(ecode1)) {
06433 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "initMG" "', argument " "1"" of type '" "int""'");
06434 }
06435 arg1 = (int)(val1);
06436 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_NOsh, 0 | 0 );
06437 if (!SWIG_IsOK(res2)) {
06438 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "initMG" "', argument " "2"" of type '" "NOsh *""'");
06439 }
06440 arg2 = (NOsh *)(argp2);
06441 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_MGparm, 0 | 0 );
06442 if (!SWIG_IsOK(res3)) {
06443 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "initMG" "', argument " "3"" of type '" "MGparm *""'");
06444 }
06445 arg3 = (MGparm *)(argp3);
06446 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_PBEparm, 0 | 0 );
06447 if (!SWIG_IsOK(res4)) {
06448 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "initMG" "', argument " "4"" of type '" "PBEparm *""'");
06449 }
06450 arg4 = (PBEparm *)(argp4);
06451 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_double, 0 | 0 );
06452 if (!SWIG_IsOK(res5)) {
06453 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "initMG" "', argument " "5"" of type '" "double [3]""'");
06454 }
06455 arg5 = (double *)(argp5);
06456 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_p_Vpbe, 0 | 0 );
06457 if (!SWIG_IsOK(res6)) {
06458 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "initMG" "', argument " "6"" of type '" "Vpbe *[NOSH_MAXCALC]""'");
06459 }
06460 arg6 = (Vpbe **)(argp6);
06461 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_p_Valist, 0 | 0 );
06462 if (!SWIG_IsOK(res7)) {
06463 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "initMG" "', argument " "7"" of type '" "Valist *[NOSH_MAXMOL]""'");
06464 }
06465 arg7 = (Valist **)(argp7);
06466 res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_p_Vgrid, 0 | 0 );
06467 if (!SWIG_IsOK(res8)) {
06468 SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "initMG" "', argument " "8"" of type '" "Vgrid *[NOSH_MAXMOL]""'");
06469 }
06470 arg8 = (Vgrid **)(argp8);
06471 res9 = SWIG_ConvertPtr(obj8, &argp9,SWIGTYPE_p_p_Vgrid, 0 | 0 );
06472 if (!SWIG_IsOK(res9)) {
06473 SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "initMG" "', argument " "9"" of type '" "Vgrid *[NOSH_MAXMOL]""'");
06474 }
06475 arg9 = (Vgrid **)(argp9);
06476 res10 = SWIG_ConvertPtr(obj9, &argp10,SWIGTYPE_p_p_Vgrid, 0 | 0 );
06477 if (!SWIG_IsOK(res10)) {
06478 SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "initMG" "', argument " "10"" of type '" "Vgrid *[NOSH_MAXMOL]""'");
06479 }
06480 arg10 = (Vgrid **)(argp10);
06481 res11 = SWIG_ConvertPtr(obj10, &argp11,SWIGTYPE_p_p_Vgrid, 0 | 0 );
06482 if (!SWIG_IsOK(res11)) {
06483 SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "initMG" "', argument " "11"" of type '" "Vgrid *[NOSH_MAXMOL]""'");
06484 }
06485 arg11 = (Vgrid **)(argp11);
06486 res12 = SWIG_ConvertPtr(obj11, &argp12,SWIGTYPE_p_p_Vgrid, 0 | 0 );
06487 if (!SWIG_IsOK(res12)) {
06488 SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "initMG" "', argument " "12"" of type '" "Vgrid *[NOSH_MAXMOL]""'");
06489 }
06490 arg12 = (Vgrid **)(argp12);
06491 res13 = SWIG_ConvertPtr(obj12, &argp13,SWIGTYPE_p_p_Vpmgp, 0 | 0 );
06492 if (!SWIG_IsOK(res13)) {
06493 SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "initMG" "', argument " "13"" of type '" "Vpmgp *[NOSH_MAXCALC]""'");
06494 }
06495 arg13 = (Vpmgp **)(argp13);
06496 res14 = SWIG_ConvertPtr(obj13, &argp14,SWIGTYPE_p_p_Vpmg, 0 | 0 );
06497 if (!SWIG_IsOK(res14)) {
06498 SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "initMG" "', argument " "14"" of type '" "Vpmg *[NOSH_MAXCALC]""'");
06499 }
06500 arg14 = (Vpmg **)(argp14);
06501 res15 = SWIG_ConvertPtr(obj14, &argp15,SWIGTYPE_p_p_Vgrid, 0 | 0 );
06502 if (!SWIG_IsOK(res15)) {
06503 SWIG_exception_fail(SWIG_ArgError(res15), "in method '" "initMG" "', argument " "15"" of type '" "Vgrid *[NOSH_MAXMOL]""'");
06504 }
06505 arg15 = (Vgrid **)(argp15);
06506 result = (int)initMG(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15);
06507 resultobj = SWIG_From_int((int)(result));
06508 return resultobj;
06509 fail:
06510 return NULL;
06511 }
06512
06513
06514 SWIGINTERN PyObject *_wrap_killMG(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06515 PyObject *resultobj = 0;
06516 NOsh *arg1 = (NOsh *) 0 ;
06517 Vpbe **arg2 ;
06518 Vpmgp **arg3 ;
06519 Vpmg **arg4 ;
06520 void *argp1 = 0 ;
06521 int res1 = 0 ;
06522 void *argp2 = 0 ;
06523 int res2 = 0 ;
06524 void *argp3 = 0 ;
06525 int res3 = 0 ;
06526 void *argp4 = 0 ;
06527 int res4 = 0 ;
06528 PyObject * obj0 = 0 ;
06529 PyObject * obj1 = 0 ;
06530 PyObject * obj2 = 0 ;
06531 PyObject * obj3 = 0 ;
06532
06533 if (!PyArg_ParseTuple(args,(char *)"OOOO:killMG",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
06534 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_NOsh, 0 | 0 );
06535 if (!SWIG_IsOK(res1)) {
06536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "killMG" "', argument " "1"" of type '" "NOsh *""'");
06537 }
06538 arg1 = (NOsh *)(argp1);
06539 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_Vpbe, 0 | 0 );
06540 if (!SWIG_IsOK(res2)) {
06541 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "killMG" "', argument " "2"" of type '" "Vpbe *[NOSH_MAXCALC]""'");
06542 }
06543 arg2 = (Vpbe **)(argp2);
06544 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_p_Vpmgp, 0 | 0 );
06545 if (!SWIG_IsOK(res3)) {
06546 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "killMG" "', argument " "3"" of type '" "Vpmgp *[NOSH_MAXCALC]""'");
06547 }
06548 arg3 = (Vpmgp **)(argp3);
06549 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_p_Vpmg, 0 | 0 );
06550 if (!SWIG_IsOK(res4)) {
06551 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "killMG" "', argument " "4"" of type '" "Vpmg *[NOSH_MAXCALC]""'");
06552 }
06553 arg4 = (Vpmg **)(argp4);
06554 killMG(arg1,arg2,arg3,arg4);
06555 resultobj = SWIG_Py_Void();
06556 return resultobj;
06557 fail:
06558 return NULL;
06559 }
06560
06561
06562 SWIGINTERN PyObject *_wrap_solveMG(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06563 PyObject *resultobj = 0;
06564 NOsh *arg1 = (NOsh *) 0 ;
06565 Vpmg *arg2 = (Vpmg *) 0 ;
06566 MGparm_CalcType arg3 ;
06567 int result;
06568 void *argp1 = 0 ;
06569 int res1 = 0 ;
06570 void *argp2 = 0 ;
06571 int res2 = 0 ;
06572 int val3 ;
06573 int ecode3 = 0 ;
06574 PyObject * obj0 = 0 ;
06575 PyObject * obj1 = 0 ;
06576 PyObject * obj2 = 0 ;
06577
06578 if (!PyArg_ParseTuple(args,(char *)"OOO:solveMG",&obj0,&obj1,&obj2)) SWIG_fail;
06579 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_NOsh, 0 | 0 );
06580 if (!SWIG_IsOK(res1)) {
06581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "solveMG" "', argument " "1"" of type '" "NOsh *""'");
06582 }
06583 arg1 = (NOsh *)(argp1);
06584 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Vpmg, 0 | 0 );
06585 if (!SWIG_IsOK(res2)) {
06586 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "solveMG" "', argument " "2"" of type '" "Vpmg *""'");
06587 }
06588 arg2 = (Vpmg *)(argp2);
06589 ecode3 = SWIG_AsVal_int(obj2, &val3);
06590 if (!SWIG_IsOK(ecode3)) {
06591 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "solveMG" "', argument " "3"" of type '" "MGparm_CalcType""'");
06592 }
06593 arg3 = (MGparm_CalcType)(val3);
06594 result = (int)solveMG(arg1,arg2,arg3);
06595 resultobj = SWIG_From_int((int)(result));
06596 return resultobj;
06597 fail:
06598 return NULL;
06599 }
06600
06601
06602 SWIGINTERN PyObject *_wrap_setPartMG(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06603 PyObject *resultobj = 0;
06604 NOsh *arg1 = (NOsh *) 0 ;
06605 MGparm *arg2 = (MGparm *) 0 ;
06606 Vpmg *arg3 = (Vpmg *) 0 ;
06607 int result;
06608 void *argp1 = 0 ;
06609 int res1 = 0 ;
06610 void *argp2 = 0 ;
06611 int res2 = 0 ;
06612 void *argp3 = 0 ;
06613 int res3 = 0 ;
06614 PyObject * obj0 = 0 ;
06615 PyObject * obj1 = 0 ;
06616 PyObject * obj2 = 0 ;
06617
06618 if (!PyArg_ParseTuple(args,(char *)"OOO:setPartMG",&obj0,&obj1,&obj2)) SWIG_fail;
06619 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_NOsh, 0 | 0 );
06620 if (!SWIG_IsOK(res1)) {
06621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "setPartMG" "', argument " "1"" of type '" "NOsh *""'");
06622 }
06623 arg1 = (NOsh *)(argp1);
06624 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_MGparm, 0 | 0 );
06625 if (!SWIG_IsOK(res2)) {
06626 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "setPartMG" "', argument " "2"" of type '" "MGparm *""'");
06627 }
06628 arg2 = (MGparm *)(argp2);
06629 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Vpmg, 0 | 0 );
06630 if (!SWIG_IsOK(res3)) {
06631 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "setPartMG" "', argument " "3"" of type '" "Vpmg *""'");
06632 }
06633 arg3 = (Vpmg *)(argp3);
06634 result = (int)setPartMG(arg1,arg2,arg3);
06635 resultobj = SWIG_From_int((int)(result));
06636 return resultobj;
06637 fail:
06638 return NULL;
06639 }
06640
06641
06642 SWIGINTERN PyObject *_wrap_killEnergy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06643 PyObject *resultobj = 0;
06644
06645 if (!PyArg_ParseTuple(args,(char *)":killEnergy")) SWIG_fail;
06646 killEnergy();
06647 resultobj = SWIG_Py_Void();
06648 return resultobj;
06649 fail:
06650 return NULL;
06651 }
06652
06653
06654 SWIGINTERN PyObject *_wrap_killForce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06655 PyObject *resultobj = 0;
06656 Vmem *arg1 = (Vmem *) 0 ;
06657 NOsh *arg2 = (NOsh *) 0 ;
06658 int *arg3 ;
06659 AtomForce **arg4 ;
06660 void *argp1 = 0 ;
06661 int res1 = 0 ;
06662 void *argp2 = 0 ;
06663 int res2 = 0 ;
06664 void *argp3 = 0 ;
06665 int res3 = 0 ;
06666 void *argp4 = 0 ;
06667 int res4 = 0 ;
06668 PyObject * obj0 = 0 ;
06669 PyObject * obj1 = 0 ;
06670 PyObject * obj2 = 0 ;
06671 PyObject * obj3 = 0 ;
06672
06673 if (!PyArg_ParseTuple(args,(char *)"OOOO:killForce",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
06674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Vmem, 0 | 0 );
06675 if (!SWIG_IsOK(res1)) {
06676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "killForce" "', argument " "1"" of type '" "Vmem *""'");
06677 }
06678 arg1 = (Vmem *)(argp1);
06679 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_NOsh, 0 | 0 );
06680 if (!SWIG_IsOK(res2)) {
06681 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "killForce" "', argument " "2"" of type '" "NOsh *""'");
06682 }
06683 arg2 = (NOsh *)(argp2);
06684 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_int, 0 | 0 );
06685 if (!SWIG_IsOK(res3)) {
06686 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "killForce" "', argument " "3"" of type '" "int [NOSH_MAXCALC]""'");
06687 }
06688 arg3 = (int *)(argp3);
06689 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_p_AtomForce, 0 | 0 );
06690 if (!SWIG_IsOK(res4)) {
06691 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "killForce" "', argument " "4"" of type '" "AtomForce *[NOSH_MAXCALC]""'");
06692 }
06693 arg4 = (AtomForce **)(argp4);
06694 killForce(arg1,arg2,arg3,arg4);
06695 resultobj = SWIG_Py_Void();
06696 return resultobj;
06697 fail:
06698 return NULL;
06699 }
06700
06701
06702 SWIGINTERN PyObject *_wrap_writedataMG(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06703 PyObject *resultobj = 0;
06704 int arg1 ;
06705 NOsh *arg2 = (NOsh *) 0 ;
06706 PBEparm *arg3 = (PBEparm *) 0 ;
06707 Vpmg *arg4 = (Vpmg *) 0 ;
06708 int result;
06709 int val1 ;
06710 int ecode1 = 0 ;
06711 void *argp2 = 0 ;
06712 int res2 = 0 ;
06713 void *argp3 = 0 ;
06714 int res3 = 0 ;
06715 void *argp4 = 0 ;
06716 int res4 = 0 ;
06717 PyObject * obj0 = 0 ;
06718 PyObject * obj1 = 0 ;
06719 PyObject * obj2 = 0 ;
06720 PyObject * obj3 = 0 ;
06721
06722 if (!PyArg_ParseTuple(args,(char *)"OOOO:writedataMG",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
06723 ecode1 = SWIG_AsVal_int(obj0, &val1);
06724 if (!SWIG_IsOK(ecode1)) {
06725 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "writedataMG" "', argument " "1"" of type '" "int""'");
06726 }
06727 arg1 = (int)(val1);
06728 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_NOsh, 0 | 0 );
06729 if (!SWIG_IsOK(res2)) {
06730 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "writedataMG" "', argument " "2"" of type '" "NOsh *""'");
06731 }
06732 arg2 = (NOsh *)(argp2);
06733 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_PBEparm, 0 | 0 );
06734 if (!SWIG_IsOK(res3)) {
06735 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "writedataMG" "', argument " "3"" of type '" "PBEparm *""'");
06736 }
06737 arg3 = (PBEparm *)(argp3);
06738 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Vpmg, 0 | 0 );
06739 if (!SWIG_IsOK(res4)) {
06740 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "writedataMG" "', argument " "4"" of type '" "Vpmg *""'");
06741 }
06742 arg4 = (Vpmg *)(argp4);
06743 result = (int)writedataMG(arg1,arg2,arg3,arg4);
06744 resultobj = SWIG_From_int((int)(result));
06745 return resultobj;
06746 fail:
06747 return NULL;
06748 }
06749
06750
06751 SWIGINTERN PyObject *_wrap_writematMG(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06752 PyObject *resultobj = 0;
06753 int arg1 ;
06754 NOsh *arg2 = (NOsh *) 0 ;
06755 PBEparm *arg3 = (PBEparm *) 0 ;
06756 Vpmg *arg4 = (Vpmg *) 0 ;
06757 int result;
06758 int val1 ;
06759 int ecode1 = 0 ;
06760 void *argp2 = 0 ;
06761 int res2 = 0 ;
06762 void *argp3 = 0 ;
06763 int res3 = 0 ;
06764 void *argp4 = 0 ;
06765 int res4 = 0 ;
06766 PyObject * obj0 = 0 ;
06767 PyObject * obj1 = 0 ;
06768 PyObject * obj2 = 0 ;
06769 PyObject * obj3 = 0 ;
06770
06771 if (!PyArg_ParseTuple(args,(char *)"OOOO:writematMG",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
06772 ecode1 = SWIG_AsVal_int(obj0, &val1);
06773 if (!SWIG_IsOK(ecode1)) {
06774 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "writematMG" "', argument " "1"" of type '" "int""'");
06775 }
06776 arg1 = (int)(val1);
06777 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_NOsh, 0 | 0 );
06778 if (!SWIG_IsOK(res2)) {
06779 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "writematMG" "', argument " "2"" of type '" "NOsh *""'");
06780 }
06781 arg2 = (NOsh *)(argp2);
06782 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_PBEparm, 0 | 0 );
06783 if (!SWIG_IsOK(res3)) {
06784 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "writematMG" "', argument " "3"" of type '" "PBEparm *""'");
06785 }
06786 arg3 = (PBEparm *)(argp3);
06787 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_Vpmg, 0 | 0 );
06788 if (!SWIG_IsOK(res4)) {
06789 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "writematMG" "', argument " "4"" of type '" "Vpmg *""'");
06790 }
06791 arg4 = (Vpmg *)(argp4);
06792 result = (int)writematMG(arg1,arg2,arg3,arg4);
06793 resultobj = SWIG_From_int((int)(result));
06794 return resultobj;
06795 fail:
06796 return NULL;
06797 }
06798
06799
06800 SWIGINTERN PyObject *_wrap_printForce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06801 PyObject *resultobj = 0;
06802 Vcom *arg1 = (Vcom *) 0 ;
06803 NOsh *arg2 = (NOsh *) 0 ;
06804 int *arg3 ;
06805 AtomForce **arg4 ;
06806 int arg5 ;
06807 int result;
06808 void *argp1 = 0 ;
06809 int res1 = 0 ;
06810 void *argp2 = 0 ;
06811 int res2 = 0 ;
06812 void *argp3 = 0 ;
06813 int res3 = 0 ;
06814 void *argp4 = 0 ;
06815 int res4 = 0 ;
06816 int val5 ;
06817 int ecode5 = 0 ;
06818 PyObject * obj0 = 0 ;
06819 PyObject * obj1 = 0 ;
06820 PyObject * obj2 = 0 ;
06821 PyObject * obj3 = 0 ;
06822 PyObject * obj4 = 0 ;
06823
06824 if (!PyArg_ParseTuple(args,(char *)"OOOOO:printForce",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
06825 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Vcom, 0 | 0 );
06826 if (!SWIG_IsOK(res1)) {
06827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "printForce" "', argument " "1"" of type '" "Vcom *""'");
06828 }
06829 arg1 = (Vcom *)(argp1);
06830 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_NOsh, 0 | 0 );
06831 if (!SWIG_IsOK(res2)) {
06832 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "printForce" "', argument " "2"" of type '" "NOsh *""'");
06833 }
06834 arg2 = (NOsh *)(argp2);
06835 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_int, 0 | 0 );
06836 if (!SWIG_IsOK(res3)) {
06837 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "printForce" "', argument " "3"" of type '" "int [NOSH_MAXCALC]""'");
06838 }
06839 arg3 = (int *)(argp3);
06840 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_p_AtomForce, 0 | 0 );
06841 if (!SWIG_IsOK(res4)) {
06842 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "printForce" "', argument " "4"" of type '" "AtomForce *[NOSH_MAXCALC]""'");
06843 }
06844 arg4 = (AtomForce **)(argp4);
06845 ecode5 = SWIG_AsVal_int(obj4, &val5);
06846 if (!SWIG_IsOK(ecode5)) {
06847 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "printForce" "', argument " "5"" of type '" "int""'");
06848 }
06849 arg5 = (int)(val5);
06850 result = (int)printForce(arg1,arg2,arg3,arg4,arg5);
06851 resultobj = SWIG_From_int((int)(result));
06852 return resultobj;
06853 fail:
06854 return NULL;
06855 }
06856
06857
06858 SWIGINTERN PyObject *_wrap_printElecForce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06859 PyObject *resultobj = 0;
06860 Vcom *arg1 = (Vcom *) 0 ;
06861 NOsh *arg2 = (NOsh *) 0 ;
06862 int *arg3 ;
06863 AtomForce **arg4 ;
06864 int arg5 ;
06865 int result;
06866 void *argp1 = 0 ;
06867 int res1 = 0 ;
06868 void *argp2 = 0 ;
06869 int res2 = 0 ;
06870 void *argp3 = 0 ;
06871 int res3 = 0 ;
06872 void *argp4 = 0 ;
06873 int res4 = 0 ;
06874 int val5 ;
06875 int ecode5 = 0 ;
06876 PyObject * obj0 = 0 ;
06877 PyObject * obj1 = 0 ;
06878 PyObject * obj2 = 0 ;
06879 PyObject * obj3 = 0 ;
06880 PyObject * obj4 = 0 ;
06881
06882 if (!PyArg_ParseTuple(args,(char *)"OOOOO:printElecForce",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
06883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Vcom, 0 | 0 );
06884 if (!SWIG_IsOK(res1)) {
06885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "printElecForce" "', argument " "1"" of type '" "Vcom *""'");
06886 }
06887 arg1 = (Vcom *)(argp1);
06888 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_NOsh, 0 | 0 );
06889 if (!SWIG_IsOK(res2)) {
06890 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "printElecForce" "', argument " "2"" of type '" "NOsh *""'");
06891 }
06892 arg2 = (NOsh *)(argp2);
06893 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_int, 0 | 0 );
06894 if (!SWIG_IsOK(res3)) {
06895 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "printElecForce" "', argument " "3"" of type '" "int [NOSH_MAXCALC]""'");
06896 }
06897 arg3 = (int *)(argp3);
06898 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_p_AtomForce, 0 | 0 );
06899 if (!SWIG_IsOK(res4)) {
06900 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "printElecForce" "', argument " "4"" of type '" "AtomForce *[NOSH_MAXCALC]""'");
06901 }
06902 arg4 = (AtomForce **)(argp4);
06903 ecode5 = SWIG_AsVal_int(obj4, &val5);
06904 if (!SWIG_IsOK(ecode5)) {
06905 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "printElecForce" "', argument " "5"" of type '" "int""'");
06906 }
06907 arg5 = (int)(val5);
06908 result = (int)printElecForce(arg1,arg2,arg3,arg4,arg5);
06909 resultobj = SWIG_From_int((int)(result));
06910 return resultobj;
06911 fail:
06912 return NULL;
06913 }
06914
06915
06916 SWIGINTERN PyObject *_wrap_printApolForce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06917 PyObject *resultobj = 0;
06918 Vcom *arg1 = (Vcom *) 0 ;
06919 NOsh *arg2 = (NOsh *) 0 ;
06920 int *arg3 ;
06921 AtomForce **arg4 ;
06922 int arg5 ;
06923 int result;
06924 void *argp1 = 0 ;
06925 int res1 = 0 ;
06926 void *argp2 = 0 ;
06927 int res2 = 0 ;
06928 void *argp3 = 0 ;
06929 int res3 = 0 ;
06930 void *argp4 = 0 ;
06931 int res4 = 0 ;
06932 int val5 ;
06933 int ecode5 = 0 ;
06934 PyObject * obj0 = 0 ;
06935 PyObject * obj1 = 0 ;
06936 PyObject * obj2 = 0 ;
06937 PyObject * obj3 = 0 ;
06938 PyObject * obj4 = 0 ;
06939
06940 if (!PyArg_ParseTuple(args,(char *)"OOOOO:printApolForce",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
06941 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Vcom, 0 | 0 );
06942 if (!SWIG_IsOK(res1)) {
06943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "printApolForce" "', argument " "1"" of type '" "Vcom *""'");
06944 }
06945 arg1 = (Vcom *)(argp1);
06946 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_NOsh, 0 | 0 );
06947 if (!SWIG_IsOK(res2)) {
06948 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "printApolForce" "', argument " "2"" of type '" "NOsh *""'");
06949 }
06950 arg2 = (NOsh *)(argp2);
06951 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_int, 0 | 0 );
06952 if (!SWIG_IsOK(res3)) {
06953 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "printApolForce" "', argument " "3"" of type '" "int [NOSH_MAXCALC]""'");
06954 }
06955 arg3 = (int *)(argp3);
06956 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_p_AtomForce, 0 | 0 );
06957 if (!SWIG_IsOK(res4)) {
06958 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "printApolForce" "', argument " "4"" of type '" "AtomForce *[NOSH_MAXCALC]""'");
06959 }
06960 arg4 = (AtomForce **)(argp4);
06961 ecode5 = SWIG_AsVal_int(obj4, &val5);
06962 if (!SWIG_IsOK(ecode5)) {
06963 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "printApolForce" "', argument " "5"" of type '" "int""'");
06964 }
06965 arg5 = (int)(val5);
06966 result = (int)printApolForce(arg1,arg2,arg3,arg4,arg5);
06967 resultobj = SWIG_From_int((int)(result));
06968 return resultobj;
06969 fail:
06970 return NULL;
06971 }
06972
06973
06974 SWIGINTERN PyObject *_wrap_startVio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06975 PyObject *resultobj = 0;
06976
06977 if (!PyArg_ParseTuple(args,(char *)":startVio")) SWIG_fail;
06978 startVio();
06979 resultobj = SWIG_Py_Void();
06980 return resultobj;
06981 fail:
06982 return NULL;
06983 }
06984
06985
06986 SWIGINTERN PyObject *_wrap_Vacc_molAcc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
06987 PyObject *resultobj = 0;
06988 Vacc *arg1 = (Vacc *) 0 ;
06989 double *arg2 ;
06990 double arg3 ;
06991 double result;
06992 void *argp1 = 0 ;
06993 int res1 = 0 ;
06994 void *argp2 = 0 ;
06995 int res2 = 0 ;
06996 double val3 ;
06997 int ecode3 = 0 ;
06998 PyObject * obj0 = 0 ;
06999 PyObject * obj1 = 0 ;
07000 PyObject * obj2 = 0 ;
07001
07002 if (!PyArg_ParseTuple(args,(char *)"OOO:Vacc_molAcc",&obj0,&obj1,&obj2)) SWIG_fail;
07003 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Vacc, 0 | 0 );
07004 if (!SWIG_IsOK(res1)) {
07005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vacc_molAcc" "', argument " "1"" of type '" "Vacc *""'");
07006 }
07007 arg1 = (Vacc *)(argp1);
07008 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 );
07009 if (!SWIG_IsOK(res2)) {
07010 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vacc_molAcc" "', argument " "2"" of type '" "double [3]""'");
07011 }
07012 arg2 = (double *)(argp2);
07013 ecode3 = SWIG_AsVal_double(obj2, &val3);
07014 if (!SWIG_IsOK(ecode3)) {
07015 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Vacc_molAcc" "', argument " "3"" of type '" "double""'");
07016 }
07017 arg3 = (double)(val3);
07018 result = (double)Vacc_molAcc(arg1,arg2,arg3);
07019 resultobj = SWIG_From_double((double)(result));
07020 return resultobj;
07021 fail:
07022 return NULL;
07023 }
07024
07025
07026 SWIGINTERN PyObject *_wrap_Vacc_vdwAcc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
07027 PyObject *resultobj = 0;
07028 Vacc *arg1 = (Vacc *) 0 ;
07029 double *arg2 ;
07030 double result;
07031 void *argp1 = 0 ;
07032 int res1 = 0 ;
07033 void *argp2 = 0 ;
07034 int res2 = 0 ;
07035 PyObject * obj0 = 0 ;
07036 PyObject * obj1 = 0 ;
07037
07038 if (!PyArg_ParseTuple(args,(char *)"OO:Vacc_vdwAcc",&obj0,&obj1)) SWIG_fail;
07039 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Vacc, 0 | 0 );
07040 if (!SWIG_IsOK(res1)) {
07041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vacc_vdwAcc" "', argument " "1"" of type '" "Vacc *""'");
07042 }
07043 arg1 = (Vacc *)(argp1);
07044 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 );
07045 if (!SWIG_IsOK(res2)) {
07046 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vacc_vdwAcc" "', argument " "2"" of type '" "double [3]""'");
07047 }
07048 arg2 = (double *)(argp2);
07049 result = (double)Vacc_vdwAcc(arg1,arg2);
07050 resultobj = SWIG_From_double((double)(result));
07051 return resultobj;
07052 fail:
07053 return NULL;
07054 }
07055
07056
07057 SWIGINTERN PyObject *_wrap_energyMG(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
07058 PyObject *resultobj = 0;
07059 NOsh *arg1 = (NOsh *) 0 ;
07060 int arg2 ;
07061 Vpmg *arg3 = (Vpmg *) 0 ;
07062 int *arg4 = (int *) 0 ;
07063 double *arg5 = (double *) 0 ;
07064 double *arg6 = (double *) 0 ;
07065 double *arg7 = (double *) 0 ;
07066 double *arg8 = (double *) 0 ;
07067 int result;
07068 void *argp1 = 0 ;
07069 int res1 = 0 ;
07070 int val2 ;
07071 int ecode2 = 0 ;
07072 void *argp3 = 0 ;
07073 int res3 = 0 ;
07074 int temp4 ;
07075 int res4 = 0 ;
07076 double temp5 ;
07077 int res5 = 0 ;
07078 double temp6 ;
07079 int res6 = 0 ;
07080 double temp7 ;
07081 int res7 = 0 ;
07082 double temp8 ;
07083 int res8 = 0 ;
07084 PyObject * obj0 = 0 ;
07085 PyObject * obj1 = 0 ;
07086 PyObject * obj2 = 0 ;
07087 PyObject * obj3 = 0 ;
07088 PyObject * obj4 = 0 ;
07089 PyObject * obj5 = 0 ;
07090 PyObject * obj6 = 0 ;
07091 PyObject * obj7 = 0 ;
07092
07093 if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:energyMG",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
07094 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_NOsh, 0 | 0 );
07095 if (!SWIG_IsOK(res1)) {
07096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "energyMG" "', argument " "1"" of type '" "NOsh *""'");
07097 }
07098 arg1 = (NOsh *)(argp1);
07099 ecode2 = SWIG_AsVal_int(obj1, &val2);
07100 if (!SWIG_IsOK(ecode2)) {
07101 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "energyMG" "', argument " "2"" of type '" "int""'");
07102 }
07103 arg2 = (int)(val2);
07104 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_Vpmg, 0 | 0 );
07105 if (!SWIG_IsOK(res3)) {
07106 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "energyMG" "', argument " "3"" of type '" "Vpmg *""'");
07107 }
07108 arg3 = (Vpmg *)(argp3);
07109 if (!(SWIG_IsOK((res4 = SWIG_ConvertPtr(obj3,SWIG_as_voidptrptr(&arg4),SWIGTYPE_p_int,0))))) {
07110 int val;
07111 int ecode = SWIG_AsVal_int(obj3, &val);
07112 if (!SWIG_IsOK(ecode)) {
07113 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "energyMG" "', argument " "4"" of type '" "int""'");
07114 }
07115 temp4 = (int)(val);
07116 arg4 = &temp4;
07117 res4 = SWIG_AddTmpMask(ecode);
07118 }
07119 if (!(SWIG_IsOK((res5 = SWIG_ConvertPtr(obj4,SWIG_as_voidptrptr(&arg5),SWIGTYPE_p_double,0))))) {
07120 double val;
07121 int ecode = SWIG_AsVal_double(obj4, &val);
07122 if (!SWIG_IsOK(ecode)) {
07123 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "energyMG" "', argument " "5"" of type '" "double""'");
07124 }
07125 temp5 = (double)(val);
07126 arg5 = &temp5;
07127 res5 = SWIG_AddTmpMask(ecode);
07128 }
07129 if (!(SWIG_IsOK((res6 = SWIG_ConvertPtr(obj5,SWIG_as_voidptrptr(&arg6),SWIGTYPE_p_double,0))))) {
07130 double val;
07131 int ecode = SWIG_AsVal_double(obj5, &val);
07132 if (!SWIG_IsOK(ecode)) {
07133 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "energyMG" "', argument " "6"" of type '" "double""'");
07134 }
07135 temp6 = (double)(val);
07136 arg6 = &temp6;
07137 res6 = SWIG_AddTmpMask(ecode);
07138 }
07139 if (!(SWIG_IsOK((res7 = SWIG_ConvertPtr(obj6,SWIG_as_voidptrptr(&arg7),SWIGTYPE_p_double,0))))) {
07140 double val;
07141 int ecode = SWIG_AsVal_double(obj6, &val);
07142 if (!SWIG_IsOK(ecode)) {
07143 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "energyMG" "', argument " "7"" of type '" "double""'");
07144 }
07145 temp7 = (double)(val);
07146 arg7 = &temp7;
07147 res7 = SWIG_AddTmpMask(ecode);
07148 }
07149 if (!(SWIG_IsOK((res8 = SWIG_ConvertPtr(obj7,SWIG_as_voidptrptr(&arg8),SWIGTYPE_p_double,0))))) {
07150 double val;
07151 int ecode = SWIG_AsVal_double(obj7, &val);
07152 if (!SWIG_IsOK(ecode)) {
07153 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "energyMG" "', argument " "8"" of type '" "double""'");
07154 }
07155 temp8 = (double)(val);
07156 arg8 = &temp8;
07157 res8 = SWIG_AddTmpMask(ecode);
07158 }
07159 result = (int)energyMG(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
07160 resultobj = SWIG_From_int((int)(result));
07161 if (SWIG_IsTmpObj(res5)) {
07162 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
07163 } else {
07164 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
07165 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
07166 }
07167 if (SWIG_IsNewObj(res4)) free((char*)arg4);
07168 if (SWIG_IsNewObj(res6)) free((char*)arg6);
07169 if (SWIG_IsNewObj(res7)) free((char*)arg7);
07170 if (SWIG_IsNewObj(res8)) free((char*)arg8);
07171 return resultobj;
07172 fail:
07173 if (SWIG_IsNewObj(res4)) free((char*)arg4);
07174 if (SWIG_IsNewObj(res6)) free((char*)arg6);
07175 if (SWIG_IsNewObj(res7)) free((char*)arg7);
07176 if (SWIG_IsNewObj(res8)) free((char*)arg8);
07177 return NULL;
07178 }
07179
07180
07181 SWIGINTERN PyObject *_wrap_printEnergy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
07182 PyObject *resultobj = 0;
07183 Vcom *arg1 = (Vcom *) 0 ;
07184 NOsh *arg2 = (NOsh *) 0 ;
07185 double *arg3 ;
07186 int arg4 ;
07187 int result;
07188 void *argp1 = 0 ;
07189 int res1 = 0 ;
07190 void *argp2 = 0 ;
07191 int res2 = 0 ;
07192 int val4 ;
07193 int ecode4 = 0 ;
07194 PyObject * obj0 = 0 ;
07195 PyObject * obj1 = 0 ;
07196 PyObject * obj2 = 0 ;
07197 PyObject * obj3 = 0 ;
07198
07199 if (!PyArg_ParseTuple(args,(char *)"OOOO:printEnergy",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
07200 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Vcom, 0 | 0 );
07201 if (!SWIG_IsOK(res1)) {
07202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "printEnergy" "', argument " "1"" of type '" "Vcom *""'");
07203 }
07204 arg1 = (Vcom *)(argp1);
07205 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_NOsh, 0 | 0 );
07206 if (!SWIG_IsOK(res2)) {
07207 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "printEnergy" "', argument " "2"" of type '" "NOsh *""'");
07208 }
07209 arg2 = (NOsh *)(argp2);
07210 {
07211
07212 if (PyList_Check(obj2)) {
07213 int size = PyList_Size(obj2);
07214 int i = 0;
07215 arg3 = (double *) malloc((size+1)*sizeof(double));
07216 for (i = 0; i < size; i++) {
07217 PyObject *o = PyList_GetItem(obj2,i);
07218 if (PyFloat_Check(o))
07219 arg3[i] = PyFloat_AsDouble(PyList_GetItem(obj2,i));
07220 else {
07221 PyErr_SetString(PyExc_TypeError,"list must contain floats");
07222 free(arg3);
07223 return NULL;
07224 }
07225 }
07226 arg3[i] = 0;
07227 } else {
07228 PyErr_SetString(PyExc_TypeError,"not a list");
07229 return NULL;
07230 }
07231 }
07232 ecode4 = SWIG_AsVal_int(obj3, &val4);
07233 if (!SWIG_IsOK(ecode4)) {
07234 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "printEnergy" "', argument " "4"" of type '" "int""'");
07235 }
07236 arg4 = (int)(val4);
07237 result = (int)printEnergy(arg1,arg2,arg3,arg4);
07238 resultobj = SWIG_From_int((int)(result));
07239 return resultobj;
07240 fail:
07241 return NULL;
07242 }
07243
07244
07245 SWIGINTERN PyObject *_wrap_printElecEnergy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
07246 PyObject *resultobj = 0;
07247 Vcom *arg1 = (Vcom *) 0 ;
07248 NOsh *arg2 = (NOsh *) 0 ;
07249 double *arg3 ;
07250 int arg4 ;
07251 int result;
07252 void *argp1 = 0 ;
07253 int res1 = 0 ;
07254 void *argp2 = 0 ;
07255 int res2 = 0 ;
07256 int val4 ;
07257 int ecode4 = 0 ;
07258 PyObject * obj0 = 0 ;
07259 PyObject * obj1 = 0 ;
07260 PyObject * obj2 = 0 ;
07261 PyObject * obj3 = 0 ;
07262
07263 if (!PyArg_ParseTuple(args,(char *)"OOOO:printElecEnergy",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
07264 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Vcom, 0 | 0 );
07265 if (!SWIG_IsOK(res1)) {
07266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "printElecEnergy" "', argument " "1"" of type '" "Vcom *""'");
07267 }
07268 arg1 = (Vcom *)(argp1);
07269 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_NOsh, 0 | 0 );
07270 if (!SWIG_IsOK(res2)) {
07271 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "printElecEnergy" "', argument " "2"" of type '" "NOsh *""'");
07272 }
07273 arg2 = (NOsh *)(argp2);
07274 {
07275
07276 if (PyList_Check(obj2)) {
07277 int size = PyList_Size(obj2);
07278 int i = 0;
07279 arg3 = (double *) malloc((size+1)*sizeof(double));
07280 for (i = 0; i < size; i++) {
07281 PyObject *o = PyList_GetItem(obj2,i);
07282 if (PyFloat_Check(o))
07283 arg3[i] = PyFloat_AsDouble(PyList_GetItem(obj2,i));
07284 else {
07285 PyErr_SetString(PyExc_TypeError,"list must contain floats");
07286 free(arg3);
07287 return NULL;
07288 }
07289 }
07290 arg3[i] = 0;
07291 } else {
07292 PyErr_SetString(PyExc_TypeError,"not a list");
07293 return NULL;
07294 }
07295 }
07296 ecode4 = SWIG_AsVal_int(obj3, &val4);
07297 if (!SWIG_IsOK(ecode4)) {
07298 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "printElecEnergy" "', argument " "4"" of type '" "int""'");
07299 }
07300 arg4 = (int)(val4);
07301 result = (int)printElecEnergy(arg1,arg2,arg3,arg4);
07302 resultobj = SWIG_From_int((int)(result));
07303 return resultobj;
07304 fail:
07305 return NULL;
07306 }
07307
07308
07309 SWIGINTERN PyObject *_wrap_printApolEnergy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
07310 PyObject *resultobj = 0;
07311 NOsh *arg1 = (NOsh *) 0 ;
07312 int arg2 ;
07313 int result;
07314 void *argp1 = 0 ;
07315 int res1 = 0 ;
07316 int val2 ;
07317 int ecode2 = 0 ;
07318 PyObject * obj0 = 0 ;
07319 PyObject * obj1 = 0 ;
07320
07321 if (!PyArg_ParseTuple(args,(char *)"OO:printApolEnergy",&obj0,&obj1)) SWIG_fail;
07322 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_NOsh, 0 | 0 );
07323 if (!SWIG_IsOK(res1)) {
07324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "printApolEnergy" "', argument " "1"" of type '" "NOsh *""'");
07325 }
07326 arg1 = (NOsh *)(argp1);
07327 ecode2 = SWIG_AsVal_int(obj1, &val2);
07328 if (!SWIG_IsOK(ecode2)) {
07329 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "printApolEnergy" "', argument " "2"" of type '" "int""'");
07330 }
07331 arg2 = (int)(val2);
07332 result = (int)printApolEnergy(arg1,arg2);
07333 resultobj = SWIG_From_int((int)(result));
07334 return resultobj;
07335 fail:
07336 return NULL;
07337 }
07338
07339
07340 SWIGINTERN PyObject *_wrap_returnEnergy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
07341 PyObject *resultobj = 0;
07342 Vcom *arg1 = (Vcom *) 0 ;
07343 NOsh *arg2 = (NOsh *) 0 ;
07344 double *arg3 ;
07345 int arg4 ;
07346 double result;
07347 void *argp1 = 0 ;
07348 int res1 = 0 ;
07349 void *argp2 = 0 ;
07350 int res2 = 0 ;
07351 int val4 ;
07352 int ecode4 = 0 ;
07353 PyObject * obj0 = 0 ;
07354 PyObject * obj1 = 0 ;
07355 PyObject * obj2 = 0 ;
07356 PyObject * obj3 = 0 ;
07357
07358 if (!PyArg_ParseTuple(args,(char *)"OOOO:returnEnergy",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
07359 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Vcom, 0 | 0 );
07360 if (!SWIG_IsOK(res1)) {
07361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "returnEnergy" "', argument " "1"" of type '" "Vcom *""'");
07362 }
07363 arg1 = (Vcom *)(argp1);
07364 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_NOsh, 0 | 0 );
07365 if (!SWIG_IsOK(res2)) {
07366 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "returnEnergy" "', argument " "2"" of type '" "NOsh *""'");
07367 }
07368 arg2 = (NOsh *)(argp2);
07369 {
07370
07371 if (PyList_Check(obj2)) {
07372 int size = PyList_Size(obj2);
07373 int i = 0;
07374 arg3 = (double *) malloc((size+1)*sizeof(double));
07375 for (i = 0; i < size; i++) {
07376 PyObject *o = PyList_GetItem(obj2,i);
07377 if (PyFloat_Check(o))
07378 arg3[i] = PyFloat_AsDouble(PyList_GetItem(obj2,i));
07379 else {
07380 PyErr_SetString(PyExc_TypeError,"list must contain floats");
07381 free(arg3);
07382 return NULL;
07383 }
07384 }
07385 arg3[i] = 0;
07386 } else {
07387 PyErr_SetString(PyExc_TypeError,"not a list");
07388 return NULL;
07389 }
07390 }
07391 ecode4 = SWIG_AsVal_int(obj3, &val4);
07392 if (!SWIG_IsOK(ecode4)) {
07393 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "returnEnergy" "', argument " "4"" of type '" "int""'");
07394 }
07395 arg4 = (int)(val4);
07396 result = (double)returnEnergy(arg1,arg2,arg3,arg4);
07397 resultobj = SWIG_From_double((double)(result));
07398 return resultobj;
07399 fail:
07400 return NULL;
07401 }
07402
07403
07404 static PyMethodDef SwigMethods[] = {
07405 { (char *)"new_Valist", _wrap_new_Valist, METH_VARARGS, NULL},
07406 { (char *)"delete_Valist", _wrap_delete_Valist, METH_VARARGS, NULL},
07407 { (char *)"Valist_number_set", _wrap_Valist_number_set, METH_VARARGS, NULL},
07408 { (char *)"Valist_number_get", _wrap_Valist_number_get, METH_VARARGS, NULL},
07409 { (char *)"Valist_swigregister", Valist_swigregister, METH_VARARGS, NULL},
07410 { (char *)"Valist_getAtomList", _wrap_Valist_getAtomList, METH_VARARGS, NULL},
07411 { (char *)"Valist_getAtom", _wrap_Valist_getAtom, METH_VARARGS, NULL},
07412 { (char *)"new_Vatom", _wrap_new_Vatom, METH_VARARGS, NULL},
07413 { (char *)"delete_Vatom", _wrap_delete_Vatom, METH_VARARGS, NULL},
07414 { (char *)"Vatom_id_set", _wrap_Vatom_id_set, METH_VARARGS, NULL},
07415 { (char *)"Vatom_id_get", _wrap_Vatom_id_get, METH_VARARGS, NULL},
07416 { (char *)"Vatom_swigregister", Vatom_swigregister, METH_VARARGS, NULL},
07417 { (char *)"Vatom_getPosition", _wrap_Vatom_getPosition, METH_VARARGS, NULL},
07418 { (char *)"Vatom_setCharge", _wrap_Vatom_setCharge, METH_VARARGS, NULL},
07419 { (char *)"Vatom_getCharge", _wrap_Vatom_getCharge, METH_VARARGS, NULL},
07420 { (char *)"Vatom_getRadius", _wrap_Vatom_getRadius, METH_VARARGS, NULL},
07421 { (char *)"new_MGparm", _wrap_new_MGparm, METH_VARARGS, NULL},
07422 { (char *)"delete_MGparm", _wrap_delete_MGparm, METH_VARARGS, NULL},
07423 { (char *)"MGparm_type_set", _wrap_MGparm_type_set, METH_VARARGS, NULL},
07424 { (char *)"MGparm_type_get", _wrap_MGparm_type_get, METH_VARARGS, NULL},
07425 { (char *)"MGparm_swigregister", MGparm_swigregister, METH_VARARGS, NULL},
07426 { (char *)"MGparm_setCenterX", _wrap_MGparm_setCenterX, METH_VARARGS, NULL},
07427 { (char *)"MGparm_setCenterY", _wrap_MGparm_setCenterY, METH_VARARGS, NULL},
07428 { (char *)"MGparm_setCenterZ", _wrap_MGparm_setCenterZ, METH_VARARGS, NULL},
07429 { (char *)"new_PBEparm", _wrap_new_PBEparm, METH_VARARGS, NULL},
07430 { (char *)"delete_PBEparm", _wrap_delete_PBEparm, METH_VARARGS, NULL},
07431 { (char *)"PBEparm_temp_set", _wrap_PBEparm_temp_set, METH_VARARGS, NULL},
07432 { (char *)"PBEparm_temp_get", _wrap_PBEparm_temp_get, METH_VARARGS, NULL},
07433 { (char *)"PBEparm_pdie_set", _wrap_PBEparm_pdie_set, METH_VARARGS, NULL},
07434 { (char *)"PBEparm_pdie_get", _wrap_PBEparm_pdie_get, METH_VARARGS, NULL},
07435 { (char *)"PBEparm_sdie_set", _wrap_PBEparm_sdie_set, METH_VARARGS, NULL},
07436 { (char *)"PBEparm_sdie_get", _wrap_PBEparm_sdie_get, METH_VARARGS, NULL},
07437 { (char *)"PBEparm_molid_set", _wrap_PBEparm_molid_set, METH_VARARGS, NULL},
07438 { (char *)"PBEparm_molid_get", _wrap_PBEparm_molid_get, METH_VARARGS, NULL},
07439 { (char *)"PBEparm_swigregister", PBEparm_swigregister, METH_VARARGS, NULL},
07440 { (char *)"new_Vcom", _wrap_new_Vcom, METH_VARARGS, NULL},
07441 { (char *)"delete_Vcom", _wrap_delete_Vcom, METH_VARARGS, NULL},
07442 { (char *)"Vcom_swigregister", Vcom_swigregister, METH_VARARGS, NULL},
07443 { (char *)"Vcom_ctor", _wrap_Vcom_ctor, METH_VARARGS, NULL},
07444 { (char *)"Vcom_size", _wrap_Vcom_size, METH_VARARGS, NULL},
07445 { (char *)"Vcom_rank", _wrap_Vcom_rank, METH_VARARGS, NULL},
07446 { (char *)"new_Vmem", _wrap_new_Vmem, METH_VARARGS, NULL},
07447 { (char *)"delete_Vmem", _wrap_delete_Vmem, METH_VARARGS, NULL},
07448 { (char *)"Vmem_swigregister", Vmem_swigregister, METH_VARARGS, NULL},
07449 { (char *)"Vmem_ctor", _wrap_Vmem_ctor, METH_VARARGS, NULL},
07450 { (char *)"new_Vpmg", _wrap_new_Vpmg, METH_VARARGS, NULL},
07451 { (char *)"delete_Vpmg", _wrap_delete_Vpmg, METH_VARARGS, NULL},
07452 { (char *)"Vpmg_swigregister", Vpmg_swigregister, METH_VARARGS, NULL},
07453 { (char *)"new_Vpbe", _wrap_new_Vpbe, METH_VARARGS, NULL},
07454 { (char *)"delete_Vpbe", _wrap_delete_Vpbe, METH_VARARGS, NULL},
07455 { (char *)"Vpbe_acc_set", _wrap_Vpbe_acc_set, METH_VARARGS, NULL},
07456 { (char *)"Vpbe_acc_get", _wrap_Vpbe_acc_get, METH_VARARGS, NULL},
07457 { (char *)"Vpbe_swigregister", Vpbe_swigregister, METH_VARARGS, NULL},
07458 { (char *)"new_NOsh_calc", _wrap_new_NOsh_calc, METH_VARARGS, NULL},
07459 { (char *)"delete_NOsh_calc", _wrap_delete_NOsh_calc, METH_VARARGS, NULL},
07460 { (char *)"NOsh_calc_mgparm_set", _wrap_NOsh_calc_mgparm_set, METH_VARARGS, NULL},
07461 { (char *)"NOsh_calc_mgparm_get", _wrap_NOsh_calc_mgparm_get, METH_VARARGS, NULL},
07462 { (char *)"NOsh_calc_femparm_set", _wrap_NOsh_calc_femparm_set, METH_VARARGS, NULL},
07463 { (char *)"NOsh_calc_femparm_get", _wrap_NOsh_calc_femparm_get, METH_VARARGS, NULL},
07464 { (char *)"NOsh_calc_pbeparm_set", _wrap_NOsh_calc_pbeparm_set, METH_VARARGS, NULL},
07465 { (char *)"NOsh_calc_pbeparm_get", _wrap_NOsh_calc_pbeparm_get, METH_VARARGS, NULL},
07466 { (char *)"NOsh_calc_calctype_set", _wrap_NOsh_calc_calctype_set, METH_VARARGS, NULL},
07467 { (char *)"NOsh_calc_calctype_get", _wrap_NOsh_calc_calctype_get, METH_VARARGS, NULL},
07468 { (char *)"NOsh_calc_swigregister", NOsh_calc_swigregister, METH_VARARGS, NULL},
07469 { (char *)"new_NOsh", _wrap_new_NOsh, METH_VARARGS, NULL},
07470 { (char *)"delete_NOsh", _wrap_delete_NOsh, METH_VARARGS, NULL},
07471 { (char *)"NOsh_ncalc_set", _wrap_NOsh_ncalc_set, METH_VARARGS, NULL},
07472 { (char *)"NOsh_ncalc_get", _wrap_NOsh_ncalc_get, METH_VARARGS, NULL},
07473 { (char *)"NOsh_nprint_set", _wrap_NOsh_nprint_set, METH_VARARGS, NULL},
07474 { (char *)"NOsh_nprint_get", _wrap_NOsh_nprint_get, METH_VARARGS, NULL},
07475 { (char *)"NOsh_nelec_set", _wrap_NOsh_nelec_set, METH_VARARGS, NULL},
07476 { (char *)"NOsh_nelec_get", _wrap_NOsh_nelec_get, METH_VARARGS, NULL},
07477 { (char *)"NOsh_nmol_set", _wrap_NOsh_nmol_set, METH_VARARGS, NULL},
07478 { (char *)"NOsh_nmol_get", _wrap_NOsh_nmol_get, METH_VARARGS, NULL},
07479 { (char *)"NOsh_printwhat_set", _wrap_NOsh_printwhat_set, METH_VARARGS, NULL},
07480 { (char *)"NOsh_printwhat_get", _wrap_NOsh_printwhat_get, METH_VARARGS, NULL},
07481 { (char *)"NOsh_swigregister", NOsh_swigregister, METH_VARARGS, NULL},
07482 { (char *)"NOsh_getCalc", _wrap_NOsh_getCalc, METH_VARARGS, NULL},
07483 { (char *)"NOsh_elecname", _wrap_NOsh_elecname, METH_VARARGS, NULL},
07484 { (char *)"NOsh_elec2calc", _wrap_NOsh_elec2calc, METH_VARARGS, NULL},
07485 { (char *)"NOsh_printWhat", _wrap_NOsh_printWhat, METH_VARARGS, NULL},
07486 { (char *)"NOsh_parseInputFile", _wrap_NOsh_parseInputFile, METH_VARARGS, NULL},
07487 { (char *)"NOsh_ctor", _wrap_NOsh_ctor, METH_VARARGS, NULL},
07488 { (char *)"new_AtomForce", _wrap_new_AtomForce, METH_VARARGS, NULL},
07489 { (char *)"delete_AtomForce", _wrap_delete_AtomForce, METH_VARARGS, NULL},
07490 { (char *)"AtomForce_swigregister", AtomForce_swigregister, METH_VARARGS, NULL},
07491 { (char *)"new_valist", _wrap_new_valist, METH_VARARGS, NULL},
07492 { (char *)"get_Valist", _wrap_get_Valist, METH_VARARGS, NULL},
07493 { (char *)"new_gridlist", _wrap_new_gridlist, METH_VARARGS, NULL},
07494 { (char *)"new_pmglist", _wrap_new_pmglist, METH_VARARGS, NULL},
07495 { (char *)"get_Vpmg", _wrap_get_Vpmg, METH_VARARGS, NULL},
07496 { (char *)"new_pmgplist", _wrap_new_pmgplist, METH_VARARGS, NULL},
07497 { (char *)"new_pbelist", _wrap_new_pbelist, METH_VARARGS, NULL},
07498 { (char *)"get_Vpbe", _wrap_get_Vpbe, METH_VARARGS, NULL},
07499 { (char *)"new_atomforcelist", _wrap_new_atomforcelist, METH_VARARGS, NULL},
07500 { (char *)"delete_atomforcelist", _wrap_delete_atomforcelist, METH_VARARGS, NULL},
07501 { (char *)"delete_valist", _wrap_delete_valist, METH_VARARGS, NULL},
07502 { (char *)"delete_gridlist", _wrap_delete_gridlist, METH_VARARGS, NULL},
07503 { (char *)"delete_pmglist", _wrap_delete_pmglist, METH_VARARGS, NULL},
07504 { (char *)"delete_pmgplist", _wrap_delete_pmgplist, METH_VARARGS, NULL},
07505 { (char *)"delete_pbelist", _wrap_delete_pbelist, METH_VARARGS, NULL},
07506 { (char *)"delete_Nosh", _wrap_delete_Nosh, METH_VARARGS, NULL},
07507 { (char *)"delete_Com", _wrap_delete_Com, METH_VARARGS, NULL},
07508 { (char *)"delete_Mem", _wrap_delete_Mem, METH_VARARGS, NULL},
07509 { (char *)"get_AtomForce", _wrap_get_AtomForce, METH_VARARGS, NULL},
07510 { (char *)"make_Valist", _wrap_make_Valist, METH_VARARGS, NULL},
07511 { (char *)"remove_Valist", _wrap_remove_Valist, METH_VARARGS, NULL},
07512 { (char *)"double_array", _wrap_double_array, METH_VARARGS, NULL},
07513 { (char *)"int_array", _wrap_int_array, METH_VARARGS, NULL},
07514 { (char *)"delete_double_array", _wrap_delete_double_array, METH_VARARGS, NULL},
07515 { (char *)"delete_int_array", _wrap_delete_int_array, METH_VARARGS, NULL},
07516 { (char *)"get_entry", _wrap_get_entry, METH_VARARGS, NULL},
07517 { (char *)"set_entry", _wrap_set_entry, METH_VARARGS, NULL},
07518 { (char *)"parseInputFromString", _wrap_parseInputFromString, METH_VARARGS, NULL},
07519 { (char *)"Valist_load", _wrap_Valist_load, METH_VARARGS, NULL},
07520 { (char *)"NOsh_setupElecCalc", _wrap_NOsh_setupElecCalc, METH_VARARGS, NULL},
07521 { (char *)"NOsh_setupApolCalc", _wrap_NOsh_setupApolCalc, METH_VARARGS, NULL},
07522 { (char *)"wrap_forceMG", _wrap_wrap_forceMG, METH_VARARGS, NULL},
07523 { (char *)"getAtomPosition", _wrap_getAtomPosition, METH_VARARGS, NULL},
07524 { (char *)"getPotentials", _wrap_getPotentials, METH_VARARGS, NULL},
07525 { (char *)"getEnergies", _wrap_getEnergies, METH_VARARGS, NULL},
07526 { (char *)"getForces", _wrap_getForces, METH_VARARGS, NULL},
07527 { (char *)"loadMolecules", _wrap_loadMolecules, METH_VARARGS, NULL},
07528 { (char *)"killMolecules", _wrap_killMolecules, METH_VARARGS, NULL},
07529 { (char *)"loadDielMaps", _wrap_loadDielMaps, METH_VARARGS, NULL},
07530 { (char *)"killDielMaps", _wrap_killDielMaps, METH_VARARGS, NULL},
07531 { (char *)"loadKappaMaps", _wrap_loadKappaMaps, METH_VARARGS, NULL},
07532 { (char *)"killKappaMaps", _wrap_killKappaMaps, METH_VARARGS, NULL},
07533 { (char *)"loadPotMaps", _wrap_loadPotMaps, METH_VARARGS, NULL},
07534 { (char *)"killPotMaps", _wrap_killPotMaps, METH_VARARGS, NULL},
07535 { (char *)"loadChargeMaps", _wrap_loadChargeMaps, METH_VARARGS, NULL},
07536 { (char *)"killChargeMaps", _wrap_killChargeMaps, METH_VARARGS, NULL},
07537 { (char *)"printPBEPARM", _wrap_printPBEPARM, METH_VARARGS, NULL},
07538 { (char *)"printMGPARM", _wrap_printMGPARM, METH_VARARGS, NULL},
07539 { (char *)"initMG", _wrap_initMG, METH_VARARGS, NULL},
07540 { (char *)"killMG", _wrap_killMG, METH_VARARGS, NULL},
07541 { (char *)"solveMG", _wrap_solveMG, METH_VARARGS, NULL},
07542 { (char *)"setPartMG", _wrap_setPartMG, METH_VARARGS, NULL},
07543 { (char *)"killEnergy", _wrap_killEnergy, METH_VARARGS, NULL},
07544 { (char *)"killForce", _wrap_killForce, METH_VARARGS, NULL},
07545 { (char *)"writedataMG", _wrap_writedataMG, METH_VARARGS, NULL},
07546 { (char *)"writematMG", _wrap_writematMG, METH_VARARGS, NULL},
07547 { (char *)"printForce", _wrap_printForce, METH_VARARGS, NULL},
07548 { (char *)"printElecForce", _wrap_printElecForce, METH_VARARGS, NULL},
07549 { (char *)"printApolForce", _wrap_printApolForce, METH_VARARGS, NULL},
07550 { (char *)"startVio", _wrap_startVio, METH_VARARGS, NULL},
07551 { (char *)"Vacc_molAcc", _wrap_Vacc_molAcc, METH_VARARGS, NULL},
07552 { (char *)"Vacc_vdwAcc", _wrap_Vacc_vdwAcc, METH_VARARGS, NULL},
07553 { (char *)"energyMG", _wrap_energyMG, METH_VARARGS, NULL},
07554 { (char *)"printEnergy", _wrap_printEnergy, METH_VARARGS, NULL},
07555 { (char *)"printElecEnergy", _wrap_printElecEnergy, METH_VARARGS, NULL},
07556 { (char *)"printApolEnergy", _wrap_printApolEnergy, METH_VARARGS, NULL},
07557 { (char *)"returnEnergy", _wrap_returnEnergy, METH_VARARGS, NULL},
07558 { NULL, NULL, 0, NULL }
07559 };
07560
07561
07562
07563
07564 static swig_type_info _swigt__p_AtomForce = {"_p_AtomForce", "AtomForce *", 0, 0, (void*)0, 0};
07565 static swig_type_info _swigt__p_FEMparm = {"_p_FEMparm", "FEMparm *", 0, 0, (void*)0, 0};
07566 static swig_type_info _swigt__p_MGparm = {"_p_MGparm", "MGparm *", 0, 0, (void*)0, 0};
07567 static swig_type_info _swigt__p_NOsh = {"_p_NOsh", "NOsh *", 0, 0, (void*)0, 0};
07568 static swig_type_info _swigt__p_NOsh_PrintType = {"_p_NOsh_PrintType", "enum NOsh_PrintType *|NOsh_PrintType *", 0, 0, (void*)0, 0};
07569 static swig_type_info _swigt__p_NOsh_calc = {"_p_NOsh_calc", "NOsh_calc *", 0, 0, (void*)0, 0};
07570 static swig_type_info _swigt__p_PBEparm = {"_p_PBEparm", "PBEparm *", 0, 0, (void*)0, 0};
07571 static swig_type_info _swigt__p_Vacc = {"_p_Vacc", "Vacc *", 0, 0, (void*)0, 0};
07572 static swig_type_info _swigt__p_Valist = {"_p_Valist", "Valist *", 0, 0, (void*)0, 0};
07573 static swig_type_info _swigt__p_Vatom = {"_p_Vatom", "Vatom *", 0, 0, (void*)0, 0};
07574 static swig_type_info _swigt__p_Vcom = {"_p_Vcom", "Vcom *", 0, 0, (void*)0, 0};
07575 static swig_type_info _swigt__p_Vmem = {"_p_Vmem", "Vmem *", 0, 0, (void*)0, 0};
07576 static swig_type_info _swigt__p_Vparam = {"_p_Vparam", "Vparam *", 0, 0, (void*)0, 0};
07577 static swig_type_info _swigt__p_Vpbe = {"_p_Vpbe", "Vpbe *", 0, 0, (void*)0, 0};
07578 static swig_type_info _swigt__p_Vpmg = {"_p_Vpmg", "Vpmg *", 0, 0, (void*)0, 0};
07579 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
07580 static swig_type_info _swigt__p_double = {"_p_double", "double *", 0, 0, (void*)0, 0};
07581 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
07582 static swig_type_info _swigt__p_p_AtomForce = {"_p_p_AtomForce", "AtomForce **", 0, 0, (void*)0, 0};
07583 static swig_type_info _swigt__p_p_Valist = {"_p_p_Valist", "Valist **", 0, 0, (void*)0, 0};
07584 static swig_type_info _swigt__p_p_Vgrid = {"_p_p_Vgrid", "Vgrid **", 0, 0, (void*)0, 0};
07585 static swig_type_info _swigt__p_p_Vpbe = {"_p_p_Vpbe", "Vpbe **", 0, 0, (void*)0, 0};
07586 static swig_type_info _swigt__p_p_Vpmg = {"_p_p_Vpmg", "Vpmg **", 0, 0, (void*)0, 0};
07587 static swig_type_info _swigt__p_p_Vpmgp = {"_p_p_Vpmgp", "Vpmgp **", 0, 0, (void*)0, 0};
07588
07589 static swig_type_info *swig_type_initial[] = {
07590 &_swigt__p_AtomForce,
07591 &_swigt__p_FEMparm,
07592 &_swigt__p_MGparm,
07593 &_swigt__p_NOsh,
07594 &_swigt__p_NOsh_PrintType,
07595 &_swigt__p_NOsh_calc,
07596 &_swigt__p_PBEparm,
07597 &_swigt__p_Vacc,
07598 &_swigt__p_Valist,
07599 &_swigt__p_Vatom,
07600 &_swigt__p_Vcom,
07601 &_swigt__p_Vmem,
07602 &_swigt__p_Vparam,
07603 &_swigt__p_Vpbe,
07604 &_swigt__p_Vpmg,
07605 &_swigt__p_char,
07606 &_swigt__p_double,
07607 &_swigt__p_int,
07608 &_swigt__p_p_AtomForce,
07609 &_swigt__p_p_Valist,
07610 &_swigt__p_p_Vgrid,
07611 &_swigt__p_p_Vpbe,
07612 &_swigt__p_p_Vpmg,
07613 &_swigt__p_p_Vpmgp,
07614 };
07615
07616 static swig_cast_info _swigc__p_AtomForce[] = { {&_swigt__p_AtomForce, 0, 0, 0},{0, 0, 0, 0}};
07617 static swig_cast_info _swigc__p_FEMparm[] = { {&_swigt__p_FEMparm, 0, 0, 0},{0, 0, 0, 0}};
07618 static swig_cast_info _swigc__p_MGparm[] = { {&_swigt__p_MGparm, 0, 0, 0},{0, 0, 0, 0}};
07619 static swig_cast_info _swigc__p_NOsh[] = { {&_swigt__p_NOsh, 0, 0, 0},{0, 0, 0, 0}};
07620 static swig_cast_info _swigc__p_NOsh_PrintType[] = { {&_swigt__p_NOsh_PrintType, 0, 0, 0},{0, 0, 0, 0}};
07621 static swig_cast_info _swigc__p_NOsh_calc[] = { {&_swigt__p_NOsh_calc, 0, 0, 0},{0, 0, 0, 0}};
07622 static swig_cast_info _swigc__p_PBEparm[] = { {&_swigt__p_PBEparm, 0, 0, 0},{0, 0, 0, 0}};
07623 static swig_cast_info _swigc__p_Vacc[] = { {&_swigt__p_Vacc, 0, 0, 0},{0, 0, 0, 0}};
07624 static swig_cast_info _swigc__p_Valist[] = { {&_swigt__p_Valist, 0, 0, 0},{0, 0, 0, 0}};
07625 static swig_cast_info _swigc__p_Vatom[] = { {&_swigt__p_Vatom, 0, 0, 0},{0, 0, 0, 0}};
07626 static swig_cast_info _swigc__p_Vcom[] = { {&_swigt__p_Vcom, 0, 0, 0},{0, 0, 0, 0}};
07627 static swig_cast_info _swigc__p_Vmem[] = { {&_swigt__p_Vmem, 0, 0, 0},{0, 0, 0, 0}};
07628 static swig_cast_info _swigc__p_Vparam[] = { {&_swigt__p_Vparam, 0, 0, 0},{0, 0, 0, 0}};
07629 static swig_cast_info _swigc__p_Vpbe[] = { {&_swigt__p_Vpbe, 0, 0, 0},{0, 0, 0, 0}};
07630 static swig_cast_info _swigc__p_Vpmg[] = { {&_swigt__p_Vpmg, 0, 0, 0},{0, 0, 0, 0}};
07631 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
07632 static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
07633 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
07634 static swig_cast_info _swigc__p_p_AtomForce[] = { {&_swigt__p_p_AtomForce, 0, 0, 0},{0, 0, 0, 0}};
07635 static swig_cast_info _swigc__p_p_Valist[] = { {&_swigt__p_p_Valist, 0, 0, 0},{0, 0, 0, 0}};
07636 static swig_cast_info _swigc__p_p_Vgrid[] = { {&_swigt__p_p_Vgrid, 0, 0, 0},{0, 0, 0, 0}};
07637 static swig_cast_info _swigc__p_p_Vpbe[] = { {&_swigt__p_p_Vpbe, 0, 0, 0},{0, 0, 0, 0}};
07638 static swig_cast_info _swigc__p_p_Vpmg[] = { {&_swigt__p_p_Vpmg, 0, 0, 0},{0, 0, 0, 0}};
07639 static swig_cast_info _swigc__p_p_Vpmgp[] = { {&_swigt__p_p_Vpmgp, 0, 0, 0},{0, 0, 0, 0}};
07640
07641 static swig_cast_info *swig_cast_initial[] = {
07642 _swigc__p_AtomForce,
07643 _swigc__p_FEMparm,
07644 _swigc__p_MGparm,
07645 _swigc__p_NOsh,
07646 _swigc__p_NOsh_PrintType,
07647 _swigc__p_NOsh_calc,
07648 _swigc__p_PBEparm,
07649 _swigc__p_Vacc,
07650 _swigc__p_Valist,
07651 _swigc__p_Vatom,
07652 _swigc__p_Vcom,
07653 _swigc__p_Vmem,
07654 _swigc__p_Vparam,
07655 _swigc__p_Vpbe,
07656 _swigc__p_Vpmg,
07657 _swigc__p_char,
07658 _swigc__p_double,
07659 _swigc__p_int,
07660 _swigc__p_p_AtomForce,
07661 _swigc__p_p_Valist,
07662 _swigc__p_p_Vgrid,
07663 _swigc__p_p_Vpbe,
07664 _swigc__p_p_Vpmg,
07665 _swigc__p_p_Vpmgp,
07666 };
07667
07668
07669
07670
07671 static swig_const_info swig_const_table[] = {
07672 {0, 0, 0, 0.0, 0, 0}};
07673
07674 #ifdef __cplusplus
07675 }
07676 #endif
07677
07678
07679
07680
07681
07682
07683
07684
07685
07686
07687
07688
07689
07690
07691
07692
07693
07694
07695
07696
07697
07698
07699
07700
07701
07702
07703
07704
07705
07706
07707
07708
07709
07710
07711
07712
07713
07714
07715
07716
07717
07718 #ifdef __cplusplus
07719 extern "C" {
07720 #if 0
07721 }
07722 #endif
07723 #endif
07724
07725 #if 0
07726 #define SWIGRUNTIME_DEBUG
07727 #endif
07728
07729
07730 SWIGRUNTIME void
07731 SWIG_InitializeModule(void *clientdata) {
07732 size_t i;
07733 swig_module_info *module_head, *iter;
07734 int found;
07735
07736 clientdata = clientdata;
07737
07738
07739 if (swig_module.next==0) {
07740
07741 swig_module.type_initial = swig_type_initial;
07742 swig_module.cast_initial = swig_cast_initial;
07743 swig_module.next = &swig_module;
07744 }
07745
07746
07747 module_head = SWIG_GetModule(clientdata);
07748 if (!module_head) {
07749
07750
07751 SWIG_SetModule(clientdata, &swig_module);
07752 module_head = &swig_module;
07753 } else {
07754
07755 found=0;
07756 iter=module_head;
07757 do {
07758 if (iter==&swig_module) {
07759 found=1;
07760 break;
07761 }
07762 iter=iter->next;
07763 } while (iter!= module_head);
07764
07765
07766 if (found) return;
07767
07768 swig_module.next = module_head->next;
07769 module_head->next = &swig_module;
07770 }
07771
07772
07773 #ifdef SWIGRUNTIME_DEBUG
07774 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
07775 #endif
07776 for (i = 0; i < swig_module.size; ++i) {
07777 swig_type_info *type = 0;
07778 swig_type_info *ret;
07779 swig_cast_info *cast;
07780
07781 #ifdef SWIGRUNTIME_DEBUG
07782 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
07783 #endif
07784
07785
07786 if (swig_module.next != &swig_module) {
07787 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
07788 }
07789 if (type) {
07790
07791 #ifdef SWIGRUNTIME_DEBUG
07792 printf("SWIG_InitializeModule: found type %s\n", type->name);
07793 #endif
07794 if (swig_module.type_initial[i]->clientdata) {
07795 type->clientdata = swig_module.type_initial[i]->clientdata;
07796 #ifdef SWIGRUNTIME_DEBUG
07797 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
07798 #endif
07799 }
07800 } else {
07801 type = swig_module.type_initial[i];
07802 }
07803
07804
07805 cast = swig_module.cast_initial[i];
07806 while (cast->type) {
07807
07808 ret = 0;
07809 #ifdef SWIGRUNTIME_DEBUG
07810 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
07811 #endif
07812 if (swig_module.next != &swig_module) {
07813 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
07814 #ifdef SWIGRUNTIME_DEBUG
07815 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
07816 #endif
07817 }
07818 if (ret) {
07819 if (type == swig_module.type_initial[i]) {
07820 #ifdef SWIGRUNTIME_DEBUG
07821 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
07822 #endif
07823 cast->type = ret;
07824 ret = 0;
07825 } else {
07826
07827 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
07828 #ifdef SWIGRUNTIME_DEBUG
07829 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
07830 #endif
07831 if (!ocast) ret = 0;
07832 }
07833 }
07834
07835 if (!ret) {
07836 #ifdef SWIGRUNTIME_DEBUG
07837 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
07838 #endif
07839 if (type->cast) {
07840 type->cast->prev = cast;
07841 cast->next = type->cast;
07842 }
07843 type->cast = cast;
07844 }
07845 cast++;
07846 }
07847
07848 swig_module.types[i] = type;
07849 }
07850 swig_module.types[i] = 0;
07851
07852 #ifdef SWIGRUNTIME_DEBUG
07853 printf("**** SWIG_InitializeModule: Cast List ******\n");
07854 for (i = 0; i < swig_module.size; ++i) {
07855 int j = 0;
07856 swig_cast_info *cast = swig_module.cast_initial[i];
07857 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
07858 while (cast->type) {
07859 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
07860 cast++;
07861 ++j;
07862 }
07863 printf("---- Total casts: %d\n",j);
07864 }
07865 printf("**** SWIG_InitializeModule: Cast List ******\n");
07866 #endif
07867 }
07868
07869
07870
07871
07872
07873
07874 SWIGRUNTIME void
07875 SWIG_PropagateClientData(void) {
07876 size_t i;
07877 swig_cast_info *equiv;
07878 static int init_run = 0;
07879
07880 if (init_run) return;
07881 init_run = 1;
07882
07883 for (i = 0; i < swig_module.size; i++) {
07884 if (swig_module.types[i]->clientdata) {
07885 equiv = swig_module.types[i]->cast;
07886 while (equiv) {
07887 if (!equiv->converter) {
07888 if (equiv->type && !equiv->type->clientdata)
07889 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
07890 }
07891 equiv = equiv->next;
07892 }
07893 }
07894 }
07895 }
07896
07897 #ifdef __cplusplus
07898 #if 0
07899 {
07900
07901 #endif
07902 }
07903 #endif
07904
07905
07906
07907 #ifdef __cplusplus
07908 extern "C" {
07909 #endif
07910
07911
07912 #define SWIG_newvarlink() SWIG_Python_newvarlink()
07913 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
07914 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
07915
07916
07917
07918
07919
07920 typedef struct swig_globalvar {
07921 char *name;
07922 PyObject *(*get_attr)(void);
07923 int (*set_attr)(PyObject *);
07924 struct swig_globalvar *next;
07925 } swig_globalvar;
07926
07927 typedef struct swig_varlinkobject {
07928 PyObject_HEAD
07929 swig_globalvar *vars;
07930 } swig_varlinkobject;
07931
07932 SWIGINTERN PyObject *
07933 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
07934 return PyString_FromString("<Swig global variables>");
07935 }
07936
07937 SWIGINTERN PyObject *
07938 swig_varlink_str(swig_varlinkobject *v) {
07939 PyObject *str = PyString_FromString("(");
07940 swig_globalvar *var;
07941 for (var = v->vars; var; var=var->next) {
07942 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
07943 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
07944 }
07945 PyString_ConcatAndDel(&str,PyString_FromString(")"));
07946 return str;
07947 }
07948
07949 SWIGINTERN int
07950 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
07951 PyObject *str = swig_varlink_str(v);
07952 fprintf(fp,"Swig global variables ");
07953 fprintf(fp,"%s\n", PyString_AsString(str));
07954 Py_DECREF(str);
07955 return 0;
07956 }
07957
07958 SWIGINTERN void
07959 swig_varlink_dealloc(swig_varlinkobject *v) {
07960 swig_globalvar *var = v->vars;
07961 while (var) {
07962 swig_globalvar *n = var->next;
07963 free(var->name);
07964 free(var);
07965 var = n;
07966 }
07967 }
07968
07969 SWIGINTERN PyObject *
07970 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
07971 PyObject *res = NULL;
07972 swig_globalvar *var = v->vars;
07973 while (var) {
07974 if (strcmp(var->name,n) == 0) {
07975 res = (*var->get_attr)();
07976 break;
07977 }
07978 var = var->next;
07979 }
07980 if (res == NULL && !PyErr_Occurred()) {
07981 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
07982 }
07983 return res;
07984 }
07985
07986 SWIGINTERN int
07987 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
07988 int res = 1;
07989 swig_globalvar *var = v->vars;
07990 while (var) {
07991 if (strcmp(var->name,n) == 0) {
07992 res = (*var->set_attr)(p);
07993 break;
07994 }
07995 var = var->next;
07996 }
07997 if (res == 1 && !PyErr_Occurred()) {
07998 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
07999 }
08000 return res;
08001 }
08002
08003 SWIGINTERN PyTypeObject*
08004 swig_varlink_type(void) {
08005 static char varlink__doc__[] = "Swig var link object";
08006 static PyTypeObject varlink_type;
08007 static int type_init = 0;
08008 if (!type_init) {
08009 const PyTypeObject tmp
08010 = {
08011 PyObject_HEAD_INIT(NULL)
08012 0,
08013 (char *)"swigvarlink",
08014 sizeof(swig_varlinkobject),
08015 0,
08016 (destructor) swig_varlink_dealloc,
08017 (printfunc) swig_varlink_print,
08018 (getattrfunc) swig_varlink_getattr,
08019 (setattrfunc) swig_varlink_setattr,
08020 0,
08021 (reprfunc) swig_varlink_repr,
08022 0,
08023 0,
08024 0,
08025 0,
08026 0,
08027 (reprfunc)swig_varlink_str,
08028 0,
08029 0,
08030 0,
08031 0,
08032 varlink__doc__,
08033 0,
08034 0,
08035 0,
08036 0,
08037 #if PY_VERSION_HEX >= 0x02020000
08038 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
08039 #endif
08040 #if PY_VERSION_HEX >= 0x02030000
08041 0,
08042 #endif
08043 #ifdef COUNT_ALLOCS
08044 0,0,0,0
08045 #endif
08046 };
08047 varlink_type = tmp;
08048 varlink_type.ob_type = &PyType_Type;
08049 type_init = 1;
08050 }
08051 return &varlink_type;
08052 }
08053
08054
08055 SWIGINTERN PyObject *
08056 SWIG_Python_newvarlink(void) {
08057 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
08058 if (result) {
08059 result->vars = 0;
08060 }
08061 return ((PyObject*) result);
08062 }
08063
08064 SWIGINTERN void
08065 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
08066 swig_varlinkobject *v = (swig_varlinkobject *) p;
08067 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
08068 if (gv) {
08069 size_t size = strlen(name)+1;
08070 gv->name = (char *)malloc(size);
08071 if (gv->name) {
08072 strncpy(gv->name,name,size);
08073 gv->get_attr = get_attr;
08074 gv->set_attr = set_attr;
08075 gv->next = v->vars;
08076 }
08077 }
08078 v->vars = gv;
08079 }
08080
08081 SWIGINTERN PyObject *
08082 SWIG_globals(void) {
08083 static PyObject *_SWIG_globals = 0;
08084 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
08085 return _SWIG_globals;
08086 }
08087
08088
08089
08090
08091
08092
08093 SWIGINTERN void
08094 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
08095 PyObject *obj = 0;
08096 size_t i;
08097 for (i = 0; constants[i].type; ++i) {
08098 switch(constants[i].type) {
08099 case SWIG_PY_POINTER:
08100 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
08101 break;
08102 case SWIG_PY_BINARY:
08103 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
08104 break;
08105 default:
08106 obj = 0;
08107 break;
08108 }
08109 if (obj) {
08110 PyDict_SetItemString(d, constants[i].name, obj);
08111 Py_DECREF(obj);
08112 }
08113 }
08114 }
08115
08116
08117
08118
08119
08120 SWIGINTERN void
08121 SWIG_Python_FixMethods(PyMethodDef *methods,
08122 swig_const_info *const_table,
08123 swig_type_info **types,
08124 swig_type_info **types_initial) {
08125 size_t i;
08126 for (i = 0; methods[i].ml_name; ++i) {
08127 const char *c = methods[i].ml_doc;
08128 if (c && (c = strstr(c, "swig_ptr: "))) {
08129 int j;
08130 swig_const_info *ci = 0;
08131 const char *name = c + 10;
08132 for (j = 0; const_table[j].type; ++j) {
08133 if (strncmp(const_table[j].name, name,
08134 strlen(const_table[j].name)) == 0) {
08135 ci = &(const_table[j]);
08136 break;
08137 }
08138 }
08139 if (ci) {
08140 size_t shift = (ci->ptype) - types;
08141 swig_type_info *ty = types_initial[shift];
08142 size_t ldoc = (c - methods[i].ml_doc);
08143 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
08144 char *ndoc = (char*)malloc(ldoc + lptr + 10);
08145 if (ndoc) {
08146 char *buff = ndoc;
08147 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
08148 if (ptr) {
08149 strncpy(buff, methods[i].ml_doc, ldoc);
08150 buff += ldoc;
08151 strncpy(buff, "swig_ptr: ", 10);
08152 buff += 10;
08153 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
08154 methods[i].ml_doc = ndoc;
08155 }
08156 }
08157 }
08158 }
08159 }
08160 }
08161
08162 #ifdef __cplusplus
08163 }
08164 #endif
08165
08166
08167
08168
08169
08170 #ifdef __cplusplus
08171 extern "C"
08172 #endif
08173 SWIGEXPORT void SWIG_init(void) {
08174 PyObject *m, *d;
08175
08176
08177 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
08178
08179 m = Py_InitModule((char *) SWIG_name, SwigMethods);
08180 d = PyModule_GetDict(m);
08181
08182 SWIG_InitializeModule(0);
08183 SWIG_InstallConstants(d,swig_const_table);
08184
08185
08186 SWIG_Python_SetConstant(d, "NPT_ENERGY",SWIG_From_int((int)(NPT_ENERGY)));
08187 SWIG_Python_SetConstant(d, "NPT_FORCE",SWIG_From_int((int)(NPT_FORCE)));
08188 SWIG_Python_SetConstant(d, "NPT_ELECENERGY",SWIG_From_int((int)(NPT_ELECENERGY)));
08189 SWIG_Python_SetConstant(d, "NPT_ELECFORCE",SWIG_From_int((int)(NPT_ELECFORCE)));
08190 SWIG_Python_SetConstant(d, "NPT_APOLENERGY",SWIG_From_int((int)(NPT_APOLENERGY)));
08191 SWIG_Python_SetConstant(d, "NPT_APOLFORCE",SWIG_From_int((int)(NPT_APOLFORCE)));
08192 }
08193