• Main Page
  • Related Pages
  • Modules
  • Namespaces
  • Data Structures
  • Files
  • File List
  • Globals

tools/python/apbslib.c

00001 /* ----------------------------------------------------------------------------
00002  * This file was automatically generated by SWIG (http://www.swig.org).
00003  * Version 1.3.31
00004  * 
00005  * This file is not intended to be easily readable and contains a number of 
00006  * coding conventions designed to improve portability and efficiency. Do not make
00007  * changes to this file unless you know what you are doing--modify the SWIG 
00008  * interface file instead. 
00009  * ----------------------------------------------------------------------------- */
00010 
00011 #define SWIGPYTHON
00012 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
00013 /* -----------------------------------------------------------------------------
00014  *  This section contains generic SWIG labels for method/variable
00015  *  declarations/attributes, and other compiler dependent labels.
00016  * ----------------------------------------------------------------------------- */
00017 
00018 /* template workaround for compilers that cannot correctly implement the C++ standard */
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 /* inline attribute */
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 /* attribute recognised by some compilers to avoid 'unused' warnings */
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 /* internal SWIG method */
00064 #ifndef SWIGINTERN
00065 # define SWIGINTERN static SWIGUNUSED
00066 #endif
00067 
00068 /* internal inline SWIG method */
00069 #ifndef SWIGINTERNINLINE
00070 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
00071 #endif
00072 
00073 /* exporting methods */
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 /* calling conventions for Windows */
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 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
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 /* Python.h has to appear first */
00112 #include <Python.h>
00113 
00114 /* -----------------------------------------------------------------------------
00115  * swigrun.swg
00116  *
00117  * This file contains generic CAPI SWIG runtime support for pointer
00118  * type checking.
00119  * ----------------------------------------------------------------------------- */
00120 
00121 /* This should only be incremented when either the layout of swig_type_info changes,
00122    or for whatever reason, the runtime changes incompatibly */
00123 #define SWIG_RUNTIME_VERSION "3"
00124 
00125 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
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   You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
00136   creating a static or dynamic library from the swig runtime code.
00137   In 99.9% of the cases, swig just needs to declare them as 'static'.
00138   
00139   But only do this if is strictly necessary, ie, if you have problems
00140   with your compiler or so.
00141 */
00142 
00143 #ifndef SWIGRUNTIME
00144 # define SWIGRUNTIME SWIGINTERN
00145 #endif
00146 
00147 #ifndef SWIGRUNTIMEINLINE
00148 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
00149 #endif
00150 
00151 /*  Generic buffer size */
00152 #ifndef SWIG_BUFFER_SIZE
00153 # define SWIG_BUFFER_SIZE 1024
00154 #endif
00155 
00156 /* Flags for pointer conversions */
00157 #define SWIG_POINTER_DISOWN        0x1
00158 
00159 /* Flags for new pointer objects */
00160 #define SWIG_POINTER_OWN           0x1
00161 
00162 
00163 /* 
00164    Flags/methods for returning states.
00165    
00166    The swig conversion methods, as ConvertPtr, return and integer 
00167    that tells if the conversion was successful or not. And if not,
00168    an error code can be returned (see swigerrors.swg for the codes).
00169    
00170    Use the following macros/flags to set or process the returning
00171    states.
00172    
00173    In old swig versions, you usually write code as:
00174 
00175      if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
00176        // success code
00177      } else {
00178        //fail code
00179      }
00180 
00181    Now you can be more explicit as:
00182 
00183     int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
00184     if (SWIG_IsOK(res)) {
00185       // success code
00186     } else {
00187       // fail code
00188     }
00189 
00190    that seems to be the same, but now you can also do
00191 
00192     Type *ptr;
00193     int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
00194     if (SWIG_IsOK(res)) {
00195       // success code
00196       if (SWIG_IsNewObj(res) {
00197         ...
00198            delete *ptr;
00199       } else {
00200         ...
00201       }
00202     } else {
00203       // fail code
00204     }
00205     
00206    I.e., now SWIG_ConvertPtr can return new objects and you can
00207    identify the case and take care of the deallocation. Of course that
00208    requires also to SWIG_ConvertPtr to return new result values, as
00209 
00210       int SWIG_ConvertPtr(obj, ptr,...) {         
00211         if (<obj is ok>) {                                    
00212           if (<need new object>) {                            
00213             *ptr = <ptr to new allocated object>; 
00214             return SWIG_NEWOBJ;                    
00215           } else {                                            
00216             *ptr = <ptr to old object>;            
00217             return SWIG_OLDOBJ;                    
00218           }                                                   
00219         } else {                                              
00220           return SWIG_BADOBJ;                      
00221         }                                                     
00222       }
00223 
00224    Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
00225    more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
00226    swig errors code.
00227 
00228    Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
00229    allows to return the 'cast rank', for example, if you have this
00230 
00231        int food(double)
00232        int fooi(int);
00233 
00234    and you call
00235  
00236       food(1)   // cast rank '1'  (1 -> 1.0)
00237       fooi(1)   // cast rank '0'
00238 
00239    just use the SWIG_AddCast()/SWIG_CheckState()
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 /* The CastRankLimit says how many bits are used for the cast rank */
00249 #define SWIG_CASTRANKLIMIT         (1 << 8)
00250 /* The NewMask denotes the object was created (using new/malloc) */
00251 #define SWIG_NEWOBJMASK            (SWIG_CASTRANKLIMIT  << 1)
00252 /* The TmpMask is for in/out typemaps that use temporal objects */
00253 #define SWIG_TMPOBJMASK            (SWIG_NEWOBJMASK << 1)
00254 /* Simple returning values */
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 /* Check, add and del mask methods */
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 /* Cast-Rank Mode */
00269 #if defined(SWIG_CASTRANK_MODE)
00270 #  ifndef SWIG_TypeRank
00271 #    define SWIG_TypeRank             unsigned long
00272 #  endif
00273 #  ifndef SWIG_MAXCASTRANK            /* Default cast allowed */
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 /* no cast-rank mode */
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 /* Structure to store inforomation on one type */
00302 typedef struct swig_type_info {
00303   const char             *name;                        /* mangled name of this type */
00304   const char             *str;                         /* human readable name of this type */
00305   swig_dycast_func        dcast;            /* dynamic cast function down a hierarchy */
00306   struct swig_cast_info  *cast;                        /* linked list of types that can cast into this type */
00307   void                   *clientdata;                  /* language specific type data */
00308   int                    owndata;                      /* flag if the structure owns the clientdata */
00309 } swig_type_info;
00310 
00311 /* Structure to store a type and conversion function used for casting */
00312 typedef struct swig_cast_info {
00313   swig_type_info         *type;                        /* pointer to type that is equivalent to this type */
00314   swig_converter_func     converter;                   /* function to cast the void pointers */
00315   struct swig_cast_info  *next;                        /* pointer to next cast in linked list */
00316   struct swig_cast_info  *prev;                        /* pointer to the previous cast */
00317 } swig_cast_info;
00318 
00319 /* Structure used to store module information
00320  * Each module generates one structure like this, and the runtime collects
00321  * all of these structures and stores them in a circularly linked list.*/
00322 typedef struct swig_module_info {
00323   swig_type_info         **types;                      /* Array of pointers to swig_type_info structures that are in this module */
00324   size_t                 size;                      /* Number of types in this module */
00325   struct swig_module_info *next;            /* Pointer to next element in circularly linked list */
00326   swig_type_info         **type_initial;    /* Array of initially generated type structures */
00327   swig_cast_info         **cast_initial;    /* Array of initially generated casting structures */
00328   void                    *clientdata;                 /* Language specific module data */
00329 } swig_module_info;
00330 
00331 /* 
00332   Compare two type names skipping the space characters, therefore
00333   "char*" == "char *" and "Class<int>" == "Class<int >", etc.
00334 
00335   Return 0 when the two name types are equivalent, as in
00336   strncmp, but skipping ' '.
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   Check type equivalence in a name list like <name1>|<name2>|...
00351   Return 0 if not equal, 1 if equal
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   Check type equivalence in a name list like <name1>|<name2>|...
00370   Return 0 if equal, -1 if nb < tb, 1 if nb > tb
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 /* think of this as a c++ template<> or a scheme macro */
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         /* Move iter to the top of the linked list */   \
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   Check the typename
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 /* Same as previous function, except strcmp is replaced with a pointer comparison */
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   Cast a pointer up an inheritance hierarchy
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    Dynamic pointer casting. Down an inheritance hierarchy
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   Return the name associated with this type
00448 */
00449 SWIGRUNTIMEINLINE const char *
00450 SWIG_TypeName(const swig_type_info *ty) {
00451   return ty->name;
00452 }
00453 
00454 /*
00455   Return the pretty name associated with this type,
00456   that is an unmangled type name in a form presentable to the user.
00457 */
00458 SWIGRUNTIME const char *
00459 SWIG_TypePrettyName(const swig_type_info *type) {
00460   /* The "str" field contains the equivalent pretty names of the
00461      type, separated by vertical-bar characters.  We choose
00462      to print the last name, as it is often (?) the most
00463      specific. */
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    Set the clientdata field for a type
00478 */
00479 SWIGRUNTIME void
00480 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
00481   swig_cast_info *cast = ti->cast;
00482   /* if (ti->clientdata == clientdata) return; */
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   Search for a swig_type_info structure only by mangled name
00503   Search is a O(log #types)
00504   
00505   We start searching at module start, and finish searching when start == end.  
00506   Note: if start == end at the beginning of the function, we go all the way around
00507   the circular list.
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            /* since l+r >= 0, we can (>> 1) instead (/ 2) */
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; /* should never happen */
00537            }
00538       } while (l <= r);
00539     }
00540     iter = iter->next;
00541   } while (iter != end);
00542   return 0;
00543 }
00544 
00545 /*
00546   Search for a swig_type_info structure for either a mangled name or a human readable name.
00547   It first searches the mangled names of the types, which is a O(log #types)
00548   If a type is not found it then searches the human readable names, which is O(#types).
00549   
00550   We start searching at module start, and finish searching when start == end.  
00551   Note: if start == end at the beginning of the function, we go all the way around
00552   the circular list.
00553 */
00554 SWIGRUNTIME swig_type_info *
00555 SWIG_TypeQueryModule(swig_module_info *start, 
00556                      swig_module_info *end, 
00557                            const char *name) {
00558   /* STEP 1: Search the name field using binary search */
00559   swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
00560   if (ret) {
00561     return ret;
00562   } else {
00563     /* STEP 2: If the type hasn't been found, do a complete search
00564        of the str field (the human readable name) */
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   /* neither found a match */
00577   return 0;
00578 }
00579 
00580 /* 
00581    Pack binary data into a string
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    Unpack binary data from a string
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    Pack 'void *' into a string buffer.
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 /*  Errors in SWIG */
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 /* Add PyOS_snprintf for old Pythons */
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 /* A crude PyString_FromFormat implementation for old Pythons */
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 /* Add PyObject_Del for old Pythons */
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 /* A crude PyExc_StopIteration exception for old Pythons */
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 /* Py_NotImplemented is defined in 2.1 and up. */
00747 #if PY_VERSION_HEX < 0x02010000
00748 # ifndef Py_NotImplemented
00749 #  define Py_NotImplemented PyExc_RuntimeError
00750 # endif
00751 #endif
00752 
00753 
00754 /* A crude PyString_AsStringAndSize implementation for old Pythons */
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 /* PySequence_Size for old Pythons */
00762 #if PY_VERSION_HEX < 0x02000000
00763 # ifndef PySequence_Size
00764 #  define PySequence_Size PySequence_Length
00765 # endif
00766 #endif
00767 
00768 
00769 /* PyBool_FromLong for old Pythons */
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 /* Py_ssize_t for old Pythons */
00781 /* This code is as recommended by: */
00782 /* http://www.python.org/dev/peps/pep-0353/#conversion-guidelines */
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  * error manipulation
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) /* Threading support is enabled */
00865 #  if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
00866 #    if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
00867 #      define SWIG_PYTHON_USE_GIL
00868 #    endif
00869 #  endif
00870 #  if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
00871 #    ifndef SWIG_PYTHON_INITIALIZE_THREADS
00872 #     define SWIG_PYTHON_INITIALIZE_THREADS  PyEval_InitThreads() 
00873 #    endif
00874 #    ifdef __cplusplus /* C++ code */
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 /* C code */
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 /* Old thread way, not implemented, user must provide it */
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 /* No thread support */
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  * Python API portion that goes into the runtime
00928  * ----------------------------------------------------------------------------- */
00929 
00930 #ifdef __cplusplus
00931 extern "C" {
00932 #if 0
00933 } /* cc-mode */
00934 #endif
00935 #endif
00936 
00937 /* -----------------------------------------------------------------------------
00938  * Constant declarations
00939  * ----------------------------------------------------------------------------- */
00940 
00941 /* Constant Types */
00942 #define SWIG_PY_POINTER 4
00943 #define SWIG_PY_BINARY  5
00944 
00945 /* Constant information structure */
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 { /* cc-mode */
00958 #endif
00959 }
00960 #endif
00961 
00962 
00963 /* -----------------------------------------------------------------------------
00964  * See the LICENSE file for information on copyright, usage and redistribution
00965  * of SWIG, and the README file for authors - http://www.swig.org/release.html.
00966  *
00967  * pyrun.swg
00968  *
00969  * This file contains the runtime support for Python modules
00970  * and includes code for managing global variables and pointer
00971  * type checking.
00972  *
00973  * ----------------------------------------------------------------------------- */
00974 
00975 /* Common SWIG API */
00976 
00977 /* for raw pointers */
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 /* for raw packed data */
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 /* for class or struct pointers */
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 /* for C or C++ function pointers */
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 /* for C++ member pointers, ie, member methods */
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 /* Runtime API */
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 /* Runtime API implementation */
01017 
01018 /* Error manipulation */
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 /* Set a constant value */
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 /* Append a value to the result obj */
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 /* Unpack the argument tuple */
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 /* A functor is a function object with one single object argument */
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   Helper for static pointer initialization for both C and C++ code, for example
01139   static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
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  * Pointer declarations
01149  * ----------------------------------------------------------------------------- */
01150 
01151 /* Flags for new pointer objects */
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 } /* cc-mode */
01161 #endif
01162 #endif
01163 
01164 /*  How to access Py_None */
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 /* The python void return value */
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 /* PySwigClientData */
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     /* the klass element */
01237     data->klass = obj;
01238     Py_INCREF(data->klass);
01239     /* the newraw method and newargs arguments used to create a new raw instance */
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     /* the destroy method, aka as the C++ delete method */
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 /* =============== PySwigObject =====================*/
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       /* destroy is always a VARARGS method */
01419       PyObject *res;
01420       if (data->delargs) {
01421            /* we need to create a temporal object to carry the destroy operation */
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, /*nb_add*/
01572     (binaryfunc)0, /*nb_subtract*/
01573     (binaryfunc)0, /*nb_multiply*/
01574     (binaryfunc)0, /*nb_divide*/
01575     (binaryfunc)0, /*nb_remainder*/
01576     (binaryfunc)0, /*nb_divmod*/
01577     (ternaryfunc)0,/*nb_power*/
01578     (unaryfunc)0,  /*nb_negative*/
01579     (unaryfunc)0,  /*nb_positive*/
01580     (unaryfunc)0,  /*nb_absolute*/
01581     (inquiry)0,    /*nb_nonzero*/
01582     0,                   /*nb_invert*/
01583     0,                   /*nb_lshift*/
01584     0,                   /*nb_rshift*/
01585     0,                   /*nb_and*/
01586     0,                   /*nb_xor*/
01587     0,                   /*nb_or*/
01588     (coercion)0,   /*nb_coerce*/
01589     (unaryfunc)PySwigObject_long, /*nb_int*/
01590     (unaryfunc)PySwigObject_long, /*nb_long*/
01591     (unaryfunc)0,                 /*nb_float*/
01592     (unaryfunc)PySwigObject_oct,  /*nb_oct*/
01593     (unaryfunc)PySwigObject_hex,  /*nb_hex*/
01594 #if PY_VERSION_HEX >= 0x02020000
01595     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */ 
01596 #elif PY_VERSION_HEX >= 0x02000000
01597     0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
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,                                              /* ob_size */
01608            (char *)"PySwigObject",                         /* tp_name */
01609            sizeof(PySwigObject),                /* tp_basicsize */
01610            0,                                           /* tp_itemsize */
01611            (destructor)PySwigObject_dealloc,   /* tp_dealloc */
01612            (printfunc)PySwigObject_print,       /* tp_print */
01613 #if PY_VERSION_HEX < 0x02020000
01614            (getattrfunc)PySwigObject_getattr,  /* tp_getattr */ 
01615 #else
01616            (getattrfunc)0,                                 /* tp_getattr */ 
01617 #endif
01618            (setattrfunc)0,                                 /* tp_setattr */ 
01619            (cmpfunc)PySwigObject_compare,       /* tp_compare */ 
01620            (reprfunc)PySwigObject_repr,         /* tp_repr */    
01621            &PySwigObject_as_number,             /* tp_as_number */
01622            0,                                              /* tp_as_sequence */
01623            0,                                              /* tp_as_mapping */
01624            (hashfunc)0,                                    /* tp_hash */
01625            (ternaryfunc)0,                                 /* tp_call */
01626            (reprfunc)PySwigObject_str,          /* tp_str */
01627            PyObject_GenericGetAttr,            /* tp_getattro */
01628            0,                                              /* tp_setattro */
01629            0,                                        /* tp_as_buffer */
01630            Py_TPFLAGS_DEFAULT,               /* tp_flags */
01631            swigobject_doc,                   /* tp_doc */        
01632            0,                                  /* tp_traverse */
01633            0,                                  /* tp_clear */
01634            0,                                  /* tp_richcompare */
01635            0,                                  /* tp_weaklistoffset */
01636 #if PY_VERSION_HEX >= 0x02020000
01637            0,                                  /* tp_iter */
01638            0,                                  /* tp_iternext */
01639            swigobject_methods,                  /* tp_methods */ 
01640            0,                                           /* tp_members */
01641            0,                                              /* tp_getset */              
01642            0,                                           /* tp_base */                
01643            0,                                              /* tp_dict */                
01644            0,                                              /* tp_descr_get */           
01645            0,                                              /* tp_descr_set */           
01646            0,                                              /* tp_dictoffset */          
01647            0,                                              /* tp_init */                
01648            0,                                              /* tp_alloc */               
01649            0,                                           /* tp_new */                    
01650            0,                                     /* tp_free */      
01651         0,                                  /* tp_is_gc */  
01652            0,                                              /* tp_bases */   
01653            0,                                              /* tp_mro */
01654            0,                                              /* tp_cache */   
01655            0,                                              /* tp_subclasses */
01656            0,                                              /* tp_weaklist */
01657 #endif
01658 #if PY_VERSION_HEX >= 0x02030000
01659            0,                                  /* tp_del */
01660 #endif
01661 #ifdef COUNT_ALLOCS
01662            0,0,0,0                             /* tp_alloc -> tp_next */
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  * Implements a simple Swig Packed type, and use it instead of string
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,                                              /* ob_size */     
01775            (char *)"PySwigPacked",                         /* tp_name */     
01776            sizeof(PySwigPacked),                /* tp_basicsize */           
01777            0,                                              /* tp_itemsize */ 
01778            (destructor)PySwigPacked_dealloc,   /* tp_dealloc */   
01779            (printfunc)PySwigPacked_print,       /* tp_print */    
01780            (getattrfunc)0,                                 /* tp_getattr */  
01781            (setattrfunc)0,                                 /* tp_setattr */  
01782            (cmpfunc)PySwigPacked_compare,       /* tp_compare */  
01783            (reprfunc)PySwigPacked_repr,         /* tp_repr */     
01784            0,                                     /* tp_as_number */         
01785            0,                                              /* tp_as_sequence */
01786            0,                                              /* tp_as_mapping */          
01787            (hashfunc)0,                                    /* tp_hash */     
01788            (ternaryfunc)0,                                 /* tp_call */     
01789            (reprfunc)PySwigPacked_str,          /* tp_str */      
01790            PyObject_GenericGetAttr,            /* tp_getattro */
01791            0,                                              /* tp_setattro */
01792            0,                                        /* tp_as_buffer */
01793            Py_TPFLAGS_DEFAULT,               /* tp_flags */
01794            swigpacked_doc,                   /* tp_doc */
01795            0,                                  /* tp_traverse */
01796            0,                                  /* tp_clear */
01797            0,                                  /* tp_richcompare */
01798            0,                                  /* tp_weaklistoffset */
01799 #if PY_VERSION_HEX >= 0x02020000
01800            0,                                  /* tp_iter */
01801            0,                                  /* tp_iternext */
01802            0,                                        /* tp_methods */ 
01803            0,                                           /* tp_members */
01804            0,                                              /* tp_getset */              
01805            0,                                           /* tp_base */                
01806            0,                                              /* tp_dict */                
01807            0,                                              /* tp_descr_get */           
01808            0,                                              /* tp_descr_set */           
01809            0,                                              /* tp_dictoffset */          
01810            0,                                              /* tp_init */                
01811            0,                                              /* tp_alloc */               
01812            0,                                           /* tp_new */                    
01813            0,                                     /* tp_free */      
01814         0,                                  /* tp_is_gc */  
01815            0,                                              /* tp_bases */   
01816            0,                                              /* tp_mro */
01817            0,                                              /* tp_cache */   
01818            0,                                              /* tp_subclasses */
01819            0,                                              /* tp_weaklist */
01820 #endif
01821 #if PY_VERSION_HEX >= 0x02030000
01822            0,                                  /* tp_del */
01823 #endif
01824 #ifdef COUNT_ALLOCS
01825            0,0,0,0                             /* tp_alloc -> tp_next */
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  * pointers/data manipulation
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 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
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       /* a PyObject is called 'this', try to get the 'real this'
01928             PySwigObject from it */ 
01929       return SWIG_Python_GetSwigThis(obj);
01930     }
01931     return (PySwigObject *)obj;
01932   }
01933 }
01934 
01935 /* Acquire a pointer value */
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 /* Convert a pointer value */
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              /* no type cast needed */
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; /* avoid recursion and call 'explicit' constructors*/
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                           /* transfer the ownership to 'ptr' */
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 /* Convert a function ptr value */
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     /* here we get the method pointer for callbacks */
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 /* Convert a packed value value */
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       /* check type cast? */
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  * Create a new pointer object
02075  * ----------------------------------------------------------------------------- */
02076 
02077 /*
02078   Create a new instance object, whitout calling __init__, and set the
02079   'this' attribute.
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 /* Create a new pointer object */
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 /* Create a new packed object */
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  *  Get type list 
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   /* first check if module already created */
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 /* PyModule_AddObject function was introduced in Python 2.0.  The following function
02240    is copied out of Python/modsupport.c in python version 2.3.4 */
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     /* Internal error -- modules must have a dict! */
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} };/* Sentinel */
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 /* The python cached type query */
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    For backward compatibility only
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     /* add information about failing argument */
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 /* Convert a pointer value, signal an exception on a type mismatch */
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 { /* cc-mode */
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 /* -------- TYPES TABLE (BEGIN) -------- */
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 /* -------- TYPES TABLE (END) -------- */
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               @(target):= _apbslib.so
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; /* simple rint */
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               In python the user should not be able to modify the inner
02694               string representation. To warranty that, if you define
02695               SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
02696               buffer is always returned.
02697 
02698               The default behavior is just to return the pointer value,
02699               so, be careful.
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 /* Generic array of doubles and ints:
02844    Constructors, Destructors, Gets, and Sets */
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     /* Reset stat variables */
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     /* Check if is a list */
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     /* Check if is a list */
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     /* Check if is a list */
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 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
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 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
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  * Type initialization:
07679  * This problem is tough by the requirement that no dynamic 
07680  * memory is used. Also, since swig_type_info structures store pointers to 
07681  * swig_cast_info structures and swig_cast_info structures store pointers back
07682  * to swig_type_info structures, we need some lookup code at initialization. 
07683  * The idea is that swig generates all the structures that are needed. 
07684  * The runtime then collects these partially filled structures. 
07685  * The SWIG_InitializeModule function takes these initial arrays out of 
07686  * swig_module, and does all the lookup, filling in the swig_module.types
07687  * array with the correct data and linking the correct swig_cast_info
07688  * structures together.
07689  *
07690  * The generated swig_type_info structures are assigned staticly to an initial 
07691  * array. We just loop through that array, and handle each type individually.
07692  * First we lookup if this type has been already loaded, and if so, use the
07693  * loaded structure instead of the generated one. Then we have to fill in the
07694  * cast linked list. The cast data is initially stored in something like a
07695  * two-dimensional array. Each row corresponds to a type (there are the same
07696  * number of rows as there are in the swig_type_initial array). Each entry in
07697  * a column is one of the swig_cast_info structures for that type.
07698  * The cast_initial array is actually an array of arrays, because each row has
07699  * a variable number of columns. So to actually build the cast linked list,
07700  * we find the array of casts associated with the type, and loop through it 
07701  * adding the casts to the list. The one last trick we need to do is making
07702  * sure the type pointer in the swig_cast_info struct is correct.
07703  *
07704  * First off, we lookup the cast->type name to see if it is already loaded. 
07705  * There are three cases to handle:
07706  *  1) If the cast->type has already been loaded AND the type we are adding
07707  *     casting info to has not been loaded (it is in this module), THEN we
07708  *     replace the cast->type pointer with the type pointer that has already
07709  *     been loaded.
07710  *  2) If BOTH types (the one we are adding casting info to, and the 
07711  *     cast->type) are loaded, THEN the cast info has already been loaded by
07712  *     the previous module so we just ignore it.
07713  *  3) Finally, if cast->type has not already been loaded, then we add that
07714  *     swig_cast_info to the linked list (because the cast->type) pointer will
07715  *     be correct.
07716  * ----------------------------------------------------------------------------- */
07717 
07718 #ifdef __cplusplus
07719 extern "C" {
07720 #if 0
07721 } /* c-mode */
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   /* check to see if the circular list has been setup, if not, set it up */
07739   if (swig_module.next==0) {
07740     /* Initialize the swig_module */
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   /* Try and load any already created modules */
07747   module_head = SWIG_GetModule(clientdata);
07748   if (!module_head) {
07749     /* This is the first module loaded for this interpreter */
07750     /* so set the swig module into the interpreter */
07751     SWIG_SetModule(clientdata, &swig_module);
07752     module_head = &swig_module;
07753   } else {
07754     /* the interpreter has loaded a SWIG module, but has it loaded this one? */
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     /* if the is found in the list, then all is done and we may leave */
07766     if (found) return;
07767     /* otherwise we must add out module into the list */
07768     swig_module.next = module_head->next;
07769     module_head->next = &swig_module;
07770   }
07771   
07772   /* Now work on filling in swig_module.types */
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     /* if there is another module already loaded */
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       /* Overwrite clientdata field */
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     /* Insert casting types */
07805     cast = swig_module.cast_initial[i];
07806     while (cast->type) {
07807       /* Don't need to add information already in the list */
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           /* Check for casting already in the list */
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     /* Set entry in modules->types array equal to the type */
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 /* This function will propagate the clientdata field of type to
07870 * any new swig_type_info structures that have been added into the list
07871 * of equivalent types.  It is like calling
07872 * SWIG_TypeClientData(type, clientdata) a second time.
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   /* c-mode */
07901 #endif
07902 }
07903 #endif
07904 
07905 
07906 
07907 #ifdef __cplusplus
07908 extern "C" {
07909 #endif
07910   
07911   /* Python-specific SWIG API */
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    * global variable support code.
07918    * ----------------------------------------------------------------------------- */
07919   
07920   typedef struct swig_globalvar {
07921     char       *name;                  /* Name of global variable */
07922     PyObject *(*get_attr)(void);       /* Return the current value */
07923     int       (*set_attr)(PyObject *); /* Set the value */
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,                                  /* Number of items in variable part (ob_size) */
08013         (char *)"swigvarlink",              /* Type name (tp_name) */
08014         sizeof(swig_varlinkobject),         /* Basic size (tp_basicsize) */
08015         0,                                  /* Itemsize (tp_itemsize) */
08016         (destructor) swig_varlink_dealloc,   /* Deallocator (tp_dealloc) */ 
08017         (printfunc) swig_varlink_print,     /* Print (tp_print) */
08018         (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
08019         (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
08020         0,                                  /* tp_compare */
08021         (reprfunc) swig_varlink_repr,       /* tp_repr */
08022         0,                                  /* tp_as_number */
08023         0,                                  /* tp_as_sequence */
08024         0,                                  /* tp_as_mapping */
08025         0,                                  /* tp_hash */
08026         0,                                  /* tp_call */
08027         (reprfunc)swig_varlink_str,        /* tp_str */
08028         0,                                  /* tp_getattro */
08029         0,                                  /* tp_setattro */
08030         0,                                  /* tp_as_buffer */
08031         0,                                  /* tp_flags */
08032         varlink__doc__,                     /* tp_doc */
08033         0,                                  /* tp_traverse */
08034         0,                                  /* tp_clear */
08035         0,                                  /* tp_richcompare */
08036         0,                                  /* tp_weaklistoffset */
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, /* tp_iter -> tp_weaklist */
08039 #endif
08040 #if PY_VERSION_HEX >= 0x02030000
08041         0,                                  /* tp_del */
08042 #endif
08043 #ifdef COUNT_ALLOCS
08044         0,0,0,0                             /* tp_alloc -> tp_next */
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   /* Create a variable linking object for use later */
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    * constants/methods manipulation
08090    * ----------------------------------------------------------------------------- */
08091   
08092   /* Install Constants */
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   /* Fix SwigMethods to carry the callback ptrs when needed */
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  *  Partial Init method
08168  * -----------------------------------------------------------------------------*/
08169 
08170 #ifdef __cplusplus
08171 extern "C"
08172 #endif
08173 SWIGEXPORT void SWIG_init(void) {
08174   PyObject *m, *d;
08175   
08176   /* Fix SwigMethods to carry the callback ptrs when needed */
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 

Generated on Wed Oct 20 2010 11:12:21 for APBS by  doxygen 1.7.2