# This file was automatically generated by SWIG (http://www.swig.org).
# Version 2.0.11
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.




"""
SCUFF-EM is a free open-source software suite for boundary-element
analysis of problems in computational electromagnetism and related
fields.
"""


from sys import version_info
if version_info >= (2,6,0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_scuff', [dirname(__file__)])
        except ImportError:
            import _scuff
            return _scuff
        if fp is not None:
            try:
                _mod = imp.load_module('_scuff', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _scuff = swig_import_helper()
    del swig_import_helper
else:
    import _scuff
del version_info
try:
    _swig_property = property
except NameError:
    pass # Python < 2.2 doesn't have 'property'.
def _swig_setattr_nondynamic(self,class_type,name,value,static=1):
    if (name == "thisown"): return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name,None)
    if method: return method(self,value)
    if (not static):
        self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)

def _swig_setattr(self,class_type,name,value):
    return _swig_setattr_nondynamic(self,class_type,name,value,0)

def _swig_getattr(self,class_type,name):
    if (name == "thisown"): return self.this.own()
    method = class_type.__swig_getmethods__.get(name,None)
    if method: return method(self)
    raise AttributeError(name)

def _swig_repr(self):
    try: strthis = "proxy of " + self.this.__repr__()
    except: strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)

try:
    _object = object
    _newclass = 1
except AttributeError:
    class _object : pass
    _newclass = 0


PLUSMINUS = _scuff.PLUSMINUS
M_PI = _scuff.M_PI
DEG2RAD = _scuff.DEG2RAD
RAD2DEG = _scuff.RAD2DEG

def Secs():
  return _scuff.Secs()
Secs = _scuff.Secs

def Tic(MeasureBytesAllocated=False):
  return _scuff.Tic(MeasureBytesAllocated)
Tic = _scuff.Tic

def Toc(BytesAllocated=None):
  return _scuff.Toc(BytesAllocated)
Toc = _scuff.Toc

def RemoveDirectories(*args):
  return _scuff.RemoveDirectories(*args)
RemoveDirectories = _scuff.RemoveDirectories

def RemoveExtension(*args):
  return _scuff.RemoveExtension(*args)
RemoveExtension = _scuff.RemoveExtension

def GetFileExtension(*args):
  return _scuff.GetFileExtension(*args)
GetFileExtension = _scuff.GetFileExtension

def GetFileBase(*args):
  return _scuff.GetFileBase(*args)
GetFileBase = _scuff.GetFileBase

def Tokenize(*args):
  return _scuff.Tokenize(*args)
Tokenize = _scuff.Tokenize

def StrCaseCmp(*args):
  return _scuff.StrCaseCmp(*args)
StrCaseCmp = _scuff.StrCaseCmp

def fopenPath(*args):
  return _scuff.fopenPath(*args)
fopenPath = _scuff.fopenPath

def vfopen(*args):
  return _scuff.vfopen(*args)
vfopen = _scuff.vfopen

def vfopenPath(*args):
  return _scuff.vfopenPath(*args)
vfopenPath = _scuff.vfopenPath

def vmkdir(*args):
  return _scuff.vmkdir(*args)
vmkdir = _scuff.vmkdir

def vsystem(*args):
  return _scuff.vsystem(*args)
vsystem = _scuff.vsystem

def vsetenv(*args):
  return _scuff.vsetenv(*args)
vsetenv = _scuff.vsetenv

def vstrdup(*args):
  return _scuff.vstrdup(*args)
vstrdup = _scuff.vstrdup

def vstrappend(*args):
  return _scuff.vstrappend(*args)
vstrappend = _scuff.vstrappend

def ErrExit(*args):
  return _scuff.ErrExit(*args)
ErrExit = _scuff.ErrExit

def Warn(*args):
  return _scuff.Warn(*args)
Warn = _scuff.Warn

def SetLogFileName(*args):
  return _scuff.SetLogFileName(*args)
SetLogFileName = _scuff.SetLogFileName

def SetConsoleLogging():
  return _scuff.SetConsoleLogging()
SetConsoleLogging = _scuff.SetConsoleLogging

def Log(*args):
  return _scuff.Log(*args)
Log = _scuff.Log

def LogC(*args):
  return _scuff.LogC(*args)
LogC = _scuff.LogC

def MutexLog(*args):
  return _scuff.MutexLog(*args)
MutexLog = _scuff.MutexLog

def LogPercent(*args):
  return _scuff.LogPercent(*args)
LogPercent = _scuff.LogPercent

def GetNumProcs():
  return _scuff.GetNumProcs()
GetNumProcs = _scuff.GetNumProcs

def SetNumThreads(*args):
  return _scuff.SetNumThreads(*args)
SetNumThreads = _scuff.SetNumThreads

def GetNumThreads():
  return _scuff.GetNumThreads()
GetNumThreads = _scuff.GetNumThreads

def GetMemoryUsage(MemoryUsage=None):
  return _scuff.GetMemoryUsage(MemoryUsage)
GetMemoryUsage = _scuff.GetMemoryUsage

def SetCPUAffinity(*args):
  return _scuff.SetCPUAffinity(*args)
SetCPUAffinity = _scuff.SetCPUAffinity

def EnableAllCPUs():
  return _scuff.EnableAllCPUs()
EnableAllCPUs = _scuff.EnableAllCPUs

def expi(*args):
  return _scuff.expi(*args)
expi = _scuff.expi

def csqrt2(*args):
  return _scuff.csqrt2(*args)
csqrt2 = _scuff.csqrt2

def S2CD(*args):
  return _scuff.S2CD(*args)
S2CD = _scuff.S2CD

def CD2S(*args):
  return _scuff.CD2S(*args)
CD2S = _scuff.CD2S

def SetDefaultCD2SFormat(*args):
  return _scuff.SetDefaultCD2SFormat(*args)
SetDefaultCD2SFormat = _scuff.SetDefaultCD2SFormat

def z2s(*args):
  return _scuff.z2s(*args)
z2s = _scuff.z2s

def ScaleVec(*args):
  return _scuff.ScaleVec(*args)
ScaleVec = _scuff.ScaleVec

def PlusEqualsVec(*args):
  return _scuff.PlusEqualsVec(*args)
PlusEqualsVec = _scuff.PlusEqualsVec

def SetCodeMarker(*args):
  return _scuff.SetCodeMarker(*args)
SetCodeMarker = _scuff.SetCodeMarker

def InstallHRSignalHandler():
  return _scuff.InstallHRSignalHandler()
InstallHRSignalHandler = _scuff.InstallHRSignalHandler

def mallocEC(*args):
  return _scuff.mallocEC(*args)
mallocEC = _scuff.mallocEC

def reallocEC(*args):
  return _scuff.reallocEC(*args)
reallocEC = _scuff.reallocEC

def strdupEC(*args):
  return _scuff.strdupEC(*args)
strdupEC = _scuff.strdupEC

def KeyPause():
  return _scuff.KeyPause()
KeyPause = _scuff.KeyPause

def RD(*args):
  return _scuff.RD(*args)
RD = _scuff.RD

def memdup(*args):
  return _scuff.memdup(*args)
memdup = _scuff.memdup

def GetHostName():
  return _scuff.GetHostName()
GetHostName = _scuff.GetHostName

def GetTimeString():
  return _scuff.GetTimeString()
GetTimeString = _scuff.GetTimeString

def CreateUniqueFile(*args):
  return _scuff.CreateUniqueFile(*args)
CreateUniqueFile = _scuff.CreateUniqueFile

def IsFinite(*args):
  return _scuff.IsFinite(*args)
IsFinite = _scuff.IsFinite
PA_DOUBLE = _scuff.PA_DOUBLE
PA_INT = _scuff.PA_INT
PA_STRING = _scuff.PA_STRING
PA_BOOL = _scuff.PA_BOOL
PA_CDOUBLE = _scuff.PA_CDOUBLE
class ArgStruct(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArgStruct, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArgStruct, name)
    __repr__ = _swig_repr
    __swig_setmethods__["Name"] = _scuff.ArgStruct_Name_set
    __swig_getmethods__["Name"] = _scuff.ArgStruct_Name_get
    if _newclass:Name = _swig_property(_scuff.ArgStruct_Name_get, _scuff.ArgStruct_Name_set)
    __swig_setmethods__["Type"] = _scuff.ArgStruct_Type_set
    __swig_getmethods__["Type"] = _scuff.ArgStruct_Type_get
    if _newclass:Type = _swig_property(_scuff.ArgStruct_Type_get, _scuff.ArgStruct_Type_set)
    __swig_setmethods__["Storage"] = _scuff.ArgStruct_Storage_set
    __swig_getmethods__["Storage"] = _scuff.ArgStruct_Storage_get
    if _newclass:Storage = _swig_property(_scuff.ArgStruct_Storage_get, _scuff.ArgStruct_Storage_set)
    __swig_setmethods__["Default"] = _scuff.ArgStruct_Default_set
    __swig_getmethods__["Default"] = _scuff.ArgStruct_Default_get
    if _newclass:Default = _swig_property(_scuff.ArgStruct_Default_get, _scuff.ArgStruct_Default_set)
    __swig_setmethods__["Description"] = _scuff.ArgStruct_Description_set
    __swig_getmethods__["Description"] = _scuff.ArgStruct_Description_get
    if _newclass:Description = _swig_property(_scuff.ArgStruct_Description_get, _scuff.ArgStruct_Description_set)
    def __init__(self): 
        this = _scuff.new_ArgStruct()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _scuff.delete_ArgStruct
    __del__ = lambda self : None;
ArgStruct_swigregister = _scuff.ArgStruct_swigregister
ArgStruct_swigregister(ArgStruct)


def ASUsage(*args):
  return _scuff.ASUsage(*args)
ASUsage = _scuff.ASUsage

def ProcessArguments(*args):
  return _scuff.ProcessArguments(*args)
ProcessArguments = _scuff.ProcessArguments
class OptStruct(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, OptStruct, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, OptStruct, name)
    __repr__ = _swig_repr
    __swig_setmethods__["Name"] = _scuff.OptStruct_Name_set
    __swig_getmethods__["Name"] = _scuff.OptStruct_Name_get
    if _newclass:Name = _swig_property(_scuff.OptStruct_Name_get, _scuff.OptStruct_Name_set)
    __swig_setmethods__["Type"] = _scuff.OptStruct_Type_set
    __swig_getmethods__["Type"] = _scuff.OptStruct_Type_get
    if _newclass:Type = _swig_property(_scuff.OptStruct_Type_get, _scuff.OptStruct_Type_set)
    __swig_setmethods__["NumArgs"] = _scuff.OptStruct_NumArgs_set
    __swig_getmethods__["NumArgs"] = _scuff.OptStruct_NumArgs_get
    if _newclass:NumArgs = _swig_property(_scuff.OptStruct_NumArgs_get, _scuff.OptStruct_NumArgs_set)
    __swig_setmethods__["MaxInstances"] = _scuff.OptStruct_MaxInstances_set
    __swig_getmethods__["MaxInstances"] = _scuff.OptStruct_MaxInstances_get
    if _newclass:MaxInstances = _swig_property(_scuff.OptStruct_MaxInstances_get, _scuff.OptStruct_MaxInstances_set)
    __swig_setmethods__["Storage"] = _scuff.OptStruct_Storage_set
    __swig_getmethods__["Storage"] = _scuff.OptStruct_Storage_get
    if _newclass:Storage = _swig_property(_scuff.OptStruct_Storage_get, _scuff.OptStruct_Storage_set)
    __swig_setmethods__["NumInstances"] = _scuff.OptStruct_NumInstances_set
    __swig_getmethods__["NumInstances"] = _scuff.OptStruct_NumInstances_get
    if _newclass:NumInstances = _swig_property(_scuff.OptStruct_NumInstances_get, _scuff.OptStruct_NumInstances_set)
    __swig_setmethods__["Description"] = _scuff.OptStruct_Description_set
    __swig_getmethods__["Description"] = _scuff.OptStruct_Description_get
    if _newclass:Description = _swig_property(_scuff.OptStruct_Description_get, _scuff.OptStruct_Description_set)
    def __init__(self): 
        this = _scuff.new_OptStruct()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _scuff.delete_OptStruct
    __del__ = lambda self : None;
OptStruct_swigregister = _scuff.OptStruct_swigregister
OptStruct_swigregister(OptStruct)


def OSUsage(*args):
  return _scuff.OSUsage(*args)
OSUsage = _scuff.OSUsage

def ProcessOptions(*args):
  return _scuff.ProcessOptions(*args)
ProcessOptions = _scuff.ProcessOptions
LHM_REAL = _scuff.LHM_REAL
LHM_COMPLEX = _scuff.LHM_COMPLEX
LHM_NORMAL = _scuff.LHM_NORMAL
LHM_SYMMETRIC = _scuff.LHM_SYMMETRIC
LHM_HERMITIAN = _scuff.LHM_HERMITIAN
LHM_HDF5 = _scuff.LHM_HDF5
LHM_TEXT = _scuff.LHM_TEXT
LHM_AUTO = _scuff.LHM_AUTO

def LHM_AUTO_FileType(*args):
  return _scuff.LHM_AUTO_FileType(*args)
LHM_AUTO_FileType = _scuff.LHM_AUTO_FileType
LHM_HORIZONTAL = _scuff.LHM_HORIZONTAL
LHM_VERTICAL = _scuff.LHM_VERTICAL
class HVector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, HVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, HVector, name)
    __repr__ = _swig_repr
    def InitHVector(self, *args): return _scuff.HVector_InitHVector(self, *args)
    def ReadFromFile(self, *args): return _scuff.HVector_ReadFromFile(self, *args)
    def ImportFromHDF5(self, *args): return _scuff.HVector_ImportFromHDF5(self, *args)
    def ExportToHDF5(self, *args): return _scuff.HVector_ExportToHDF5(self, *args)
    def ExportToMATLAB(self, *args): return _scuff.HVector_ExportToMATLAB(self, *args)
    def ImportFromText(self, *args): return _scuff.HVector_ImportFromText(self, *args)
    def ExportToText(self, *args): return _scuff.HVector_ExportToText(self, *args)
    def __init__(self, *args): 
        this = _scuff.new_HVector(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _scuff.delete_HVector
    __del__ = lambda self : None;
    def GetEntry(self, *args): return _scuff.HVector_GetEntry(self, *args)
    def GetEntryD(self, *args): return _scuff.HVector_GetEntryD(self, *args)
    def Copy(self, *args): return _scuff.HVector_Copy(self, *args)
    def SetEntry(self, *args): return _scuff.HVector_SetEntry(self, *args)
    def AddEntry(self, *args): return _scuff.HVector_AddEntry(self, *args)
    def Scale(self, *args): return _scuff.HVector_Scale(self, *args)
    def Dot(self, *args): return _scuff.HVector_Dot(self, *args)
    def DotU(self, *args): return _scuff.HVector_DotU(self, *args)
    def DotD(self, *args): return _scuff.HVector_DotD(self, *args)
    def Zero(self): return _scuff.HVector_Zero(self)
    __swig_setmethods__["N"] = _scuff.HVector_N_set
    __swig_getmethods__["N"] = _scuff.HVector_N_get
    if _newclass:N = _swig_property(_scuff.HVector_N_get, _scuff.HVector_N_set)
    __swig_setmethods__["RealComplex"] = _scuff.HVector_RealComplex_set
    __swig_getmethods__["RealComplex"] = _scuff.HVector_RealComplex_get
    if _newclass:RealComplex = _swig_property(_scuff.HVector_RealComplex_get, _scuff.HVector_RealComplex_set)
    __swig_setmethods__["DV"] = _scuff.HVector_DV_set
    __swig_getmethods__["DV"] = _scuff.HVector_DV_get
    if _newclass:DV = _swig_property(_scuff.HVector_DV_get, _scuff.HVector_DV_set)
    __swig_setmethods__["ZV"] = _scuff.HVector_ZV_set
    __swig_getmethods__["ZV"] = _scuff.HVector_ZV_get
    if _newclass:ZV = _swig_property(_scuff.HVector_ZV_get, _scuff.HVector_ZV_set)
    __swig_setmethods__["ownsV"] = _scuff.HVector_ownsV_set
    __swig_getmethods__["ownsV"] = _scuff.HVector_ownsV_get
    if _newclass:ownsV = _swig_property(_scuff.HVector_ownsV_get, _scuff.HVector_ownsV_set)
    __swig_setmethods__["ErrMsg"] = _scuff.HVector_ErrMsg_set
    __swig_getmethods__["ErrMsg"] = _scuff.HVector_ErrMsg_get
    if _newclass:ErrMsg = _swig_property(_scuff.HVector_ErrMsg_get, _scuff.HVector_ErrMsg_set)
HVector_swigregister = _scuff.HVector_swigregister
HVector_swigregister(HVector)


def LinSpace(*args):
  return _scuff.LinSpace(*args)
LinSpace = _scuff.LinSpace

def LogSpace(*args):
  return _scuff.LogSpace(*args)
LogSpace = _scuff.LogSpace
class HMatrix(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, HMatrix, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, HMatrix, name)
    __repr__ = _swig_repr
    def InitHMatrix(self, *args): return _scuff.HMatrix_InitHMatrix(self, *args)
    def ReadFromFile(self, *args): return _scuff.HMatrix_ReadFromFile(self, *args)
    def __init__(self, *args): 
        this = _scuff.new_HMatrix(*args)
        try: self.this.append(this)
        except: self.this = this
    def ImportFromHDF5(self, *args): return _scuff.HMatrix_ImportFromHDF5(self, *args)
    def ExportToHDF5(self, *args): return _scuff.HMatrix_ExportToHDF5(self, *args)
    def ExportToMATLAB(self, *args): return _scuff.HMatrix_ExportToMATLAB(self, *args)
    def ImportFromText(self, *args): return _scuff.HMatrix_ImportFromText(self, *args)
    def ExportToText(self, *args): return _scuff.HMatrix_ExportToText(self, *args)
    __swig_destroy__ = _scuff.delete_HMatrix
    __del__ = lambda self : None;
    def GetEntry(self, *args): return _scuff.HMatrix_GetEntry(self, *args)
    def GetEntryD(self, *args): return _scuff.HMatrix_GetEntryD(self, *args)
    def SetEntry(self, *args): return _scuff.HMatrix_SetEntry(self, *args)
    def AddEntry(self, *args): return _scuff.HMatrix_AddEntry(self, *args)
    def GetEntriesD(self, *args): return _scuff.HMatrix_GetEntriesD(self, *args)
    def GetEntries(self, *args): return _scuff.HMatrix_GetEntries(self, *args)
    def ExtractEntries(self, *args): return _scuff.HMatrix_ExtractEntries(self, *args)
    def DoGetEntries(self, *args): return _scuff.HMatrix_DoGetEntries(self, *args)
    def SetEntriesD(self, *args): return _scuff.HMatrix_SetEntriesD(self, *args)
    def SetEntries(self, *args): return _scuff.HMatrix_SetEntries(self, *args)
    def DoSetEntries(self, *args): return _scuff.HMatrix_DoSetEntries(self, *args)
    def Copy(self, *args): return _scuff.HMatrix_Copy(self, *args)
    def GetTrace(self): return _scuff.HMatrix_GetTrace(self)
    def GetTraceD(self): return _scuff.HMatrix_GetTraceD(self)
    def Scale(self, *args): return _scuff.HMatrix_Scale(self, *args)
    def Zero(self): return _scuff.HMatrix_Zero(self)
    def ZeroBlock(self, *args): return _scuff.HMatrix_ZeroBlock(self, *args)
    def Adjoint(self): return _scuff.HMatrix_Adjoint(self)
    def Transpose(self): return _scuff.HMatrix_Transpose(self)
    def InsertBlockAdjoint(self, *args): return _scuff.HMatrix_InsertBlockAdjoint(self, *args)
    def InsertBlockTranspose(self, *args): return _scuff.HMatrix_InsertBlockTranspose(self, *args)
    def InsertBlock(self, *args): return _scuff.HMatrix_InsertBlock(self, *args)
    def AddBlockAdjoint(self, *args): return _scuff.HMatrix_AddBlockAdjoint(self, *args)
    def AddBlock(self, *args): return _scuff.HMatrix_AddBlock(self, *args)
    def ExtractBlock(self, *args): return _scuff.HMatrix_ExtractBlock(self, *args)
    def Sort(self, *args): return _scuff.HMatrix_Sort(self, *args)
    def BilinearProduct(self, *args): return _scuff.HMatrix_BilinearProduct(self, *args)
    def BilinearProductD(self, *args): return _scuff.HMatrix_BilinearProductD(self, *args)
    def Multiply(self, *args): return _scuff.HMatrix_Multiply(self, *args)
    def GetMatrixProductDiagonal(self, *args): return _scuff.HMatrix_GetMatrixProductDiagonal(self, *args)
    def Apply(self, *args): return _scuff.HMatrix_Apply(self, *args)
    def LUFactorize(self): return _scuff.HMatrix_LUFactorize(self)
    def LUSolve(self, *args): return _scuff.HMatrix_LUSolve(self, *args)
    def LUInvert(self): return _scuff.HMatrix_LUInvert(self)
    def CholFactorize(self): return _scuff.HMatrix_CholFactorize(self)
    def CholSolve(self, *args): return _scuff.HMatrix_CholSolve(self, *args)
    def QR(self, *args): return _scuff.HMatrix_QR(self, *args)
    def Eig(self, Lambda=None, U=None): return _scuff.HMatrix_Eig(self, Lambda, U)
    def NSEig(self, Lambda=None, U=None): return _scuff.HMatrix_NSEig(self, Lambda, U)
    def SVD(self, Sigma=None, U=None, VT=None): return _scuff.HMatrix_SVD(self, Sigma, U, VT)
    def GetNorm(self, UseInfinityNorm=False): return _scuff.HMatrix_GetNorm(self, UseInfinityNorm)
    def GetRCond(self, *args): return _scuff.HMatrix_GetRCond(self, *args)
    def NumEntries(self): return _scuff.HMatrix_NumEntries(self)
    __swig_setmethods__["NR"] = _scuff.HMatrix_NR_set
    __swig_getmethods__["NR"] = _scuff.HMatrix_NR_get
    if _newclass:NR = _swig_property(_scuff.HMatrix_NR_get, _scuff.HMatrix_NR_set)
    __swig_setmethods__["NC"] = _scuff.HMatrix_NC_set
    __swig_getmethods__["NC"] = _scuff.HMatrix_NC_get
    if _newclass:NC = _swig_property(_scuff.HMatrix_NC_get, _scuff.HMatrix_NC_set)
    __swig_setmethods__["RealComplex"] = _scuff.HMatrix_RealComplex_set
    __swig_getmethods__["RealComplex"] = _scuff.HMatrix_RealComplex_get
    if _newclass:RealComplex = _swig_property(_scuff.HMatrix_RealComplex_get, _scuff.HMatrix_RealComplex_set)
    __swig_setmethods__["StorageType"] = _scuff.HMatrix_StorageType_set
    __swig_getmethods__["StorageType"] = _scuff.HMatrix_StorageType_get
    if _newclass:StorageType = _swig_property(_scuff.HMatrix_StorageType_get, _scuff.HMatrix_StorageType_set)
    __swig_setmethods__["ipiv"] = _scuff.HMatrix_ipiv_set
    __swig_getmethods__["ipiv"] = _scuff.HMatrix_ipiv_get
    if _newclass:ipiv = _swig_property(_scuff.HMatrix_ipiv_get, _scuff.HMatrix_ipiv_set)
    __swig_setmethods__["DM"] = _scuff.HMatrix_DM_set
    __swig_getmethods__["DM"] = _scuff.HMatrix_DM_get
    if _newclass:DM = _swig_property(_scuff.HMatrix_DM_get, _scuff.HMatrix_DM_set)
    __swig_setmethods__["ZM"] = _scuff.HMatrix_ZM_set
    __swig_getmethods__["ZM"] = _scuff.HMatrix_ZM_get
    if _newclass:ZM = _swig_property(_scuff.HMatrix_ZM_get, _scuff.HMatrix_ZM_set)
    __swig_setmethods__["lwork"] = _scuff.HMatrix_lwork_set
    __swig_getmethods__["lwork"] = _scuff.HMatrix_lwork_get
    if _newclass:lwork = _swig_property(_scuff.HMatrix_lwork_get, _scuff.HMatrix_lwork_set)
    __swig_setmethods__["work"] = _scuff.HMatrix_work_set
    __swig_getmethods__["work"] = _scuff.HMatrix_work_get
    if _newclass:work = _swig_property(_scuff.HMatrix_work_get, _scuff.HMatrix_work_set)
    __swig_setmethods__["liwork"] = _scuff.HMatrix_liwork_set
    __swig_getmethods__["liwork"] = _scuff.HMatrix_liwork_get
    if _newclass:liwork = _swig_property(_scuff.HMatrix_liwork_get, _scuff.HMatrix_liwork_set)
    __swig_setmethods__["iwork"] = _scuff.HMatrix_iwork_set
    __swig_getmethods__["iwork"] = _scuff.HMatrix_iwork_get
    if _newclass:iwork = _swig_property(_scuff.HMatrix_iwork_get, _scuff.HMatrix_iwork_set)
    __swig_setmethods__["ownsM"] = _scuff.HMatrix_ownsM_set
    __swig_getmethods__["ownsM"] = _scuff.HMatrix_ownsM_get
    if _newclass:ownsM = _swig_property(_scuff.HMatrix_ownsM_get, _scuff.HMatrix_ownsM_set)
    __swig_setmethods__["ErrMsg"] = _scuff.HMatrix_ErrMsg_set
    __swig_getmethods__["ErrMsg"] = _scuff.HMatrix_ErrMsg_get
    if _newclass:ErrMsg = _swig_property(_scuff.HMatrix_ErrMsg_get, _scuff.HMatrix_ErrMsg_set)
    __swig_getmethods__["OpenHDF5Context"] = lambda x: _scuff.HMatrix_OpenHDF5Context
    if _newclass:OpenHDF5Context = staticmethod(_scuff.HMatrix_OpenHDF5Context)
    __swig_getmethods__["CloseHDF5Context"] = lambda x: _scuff.HMatrix_CloseHDF5Context
    if _newclass:CloseHDF5Context = staticmethod(_scuff.HMatrix_CloseHDF5Context)
    __swig_getmethods__["OpenMATLABContext"] = lambda x: _scuff.HMatrix_OpenMATLABContext
    if _newclass:OpenMATLABContext = staticmethod(_scuff.HMatrix_OpenMATLABContext)
    __swig_getmethods__["CloseMATLABContext"] = lambda x: _scuff.HMatrix_CloseMATLABContext
    if _newclass:CloseMATLABContext = staticmethod(_scuff.HMatrix_CloseMATLABContext)
    __swig_setmethods__["AbortOnIOError"] = _scuff.HMatrix_AbortOnIOError_set
    __swig_getmethods__["AbortOnIOError"] = _scuff.HMatrix_AbortOnIOError_get
    if _newclass:AbortOnIOError = _swig_property(_scuff.HMatrix_AbortOnIOError_get, _scuff.HMatrix_AbortOnIOError_set)
HMatrix_swigregister = _scuff.HMatrix_swigregister
HMatrix_swigregister(HMatrix)

def HMatrix_OpenHDF5Context(*args):
  return _scuff.HMatrix_OpenHDF5Context(*args)
HMatrix_OpenHDF5Context = _scuff.HMatrix_OpenHDF5Context

def HMatrix_CloseHDF5Context(*args):
  return _scuff.HMatrix_CloseHDF5Context(*args)
HMatrix_CloseHDF5Context = _scuff.HMatrix_CloseHDF5Context

def HMatrix_OpenMATLABContext(*args):
  return _scuff.HMatrix_OpenMATLABContext(*args)
HMatrix_OpenMATLABContext = _scuff.HMatrix_OpenMATLABContext

def HMatrix_CloseMATLABContext(*args):
  return _scuff.HMatrix_CloseMATLABContext(*args)
HMatrix_CloseMATLABContext = _scuff.HMatrix_CloseMATLABContext
cvar = _scuff.cvar


def CopyHMatrixUnpacked(*args):
  return _scuff.CopyHMatrixUnpacked(*args)
CopyHMatrixUnpacked = _scuff.CopyHMatrixUnpacked

def Concat(*args):
  return _scuff.Concat(*args)
Concat = _scuff.Concat
class SMatrix(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SMatrix, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SMatrix, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _scuff.new_SMatrix(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _scuff.delete_SMatrix
    __del__ = lambda self : None;
    def GetNNZ(self, *args): return _scuff.SMatrix_GetNNZ(self, *args)
    def Zero(self): return _scuff.SMatrix_Zero(self)
    def GetRow(self, *args): return _scuff.SMatrix_GetRow(self, *args)
    def GetRowEntries(self, *args): return _scuff.SMatrix_GetRowEntries(self, *args)
    def GetEntry(self, *args): return _scuff.SMatrix_GetEntry(self, *args)
    def GetEntryD(self, *args): return _scuff.SMatrix_GetEntryD(self, *args)
    def Apply(self, *args): return _scuff.SMatrix_Apply(self, *args)
    def BilinearProduct(self, *args): return _scuff.SMatrix_BilinearProduct(self, *args)
    def BilinearProductD(self, *args): return _scuff.SMatrix_BilinearProductD(self, *args)
    def BeginAssembly(self, est_nnz=0): return _scuff.SMatrix_BeginAssembly(self, est_nnz)
    def EndAssembly(self): return _scuff.SMatrix_EndAssembly(self)
    def SetEntry(self, *args): return _scuff.SMatrix_SetEntry(self, *args)
    def AddEntry(self, *args): return _scuff.SMatrix_AddEntry(self, *args)
    __swig_setmethods__["NR"] = _scuff.SMatrix_NR_set
    __swig_getmethods__["NR"] = _scuff.SMatrix_NR_get
    if _newclass:NR = _swig_property(_scuff.SMatrix_NR_get, _scuff.SMatrix_NR_set)
    __swig_setmethods__["NC"] = _scuff.SMatrix_NC_set
    __swig_getmethods__["NC"] = _scuff.SMatrix_NC_get
    if _newclass:NC = _swig_property(_scuff.SMatrix_NC_get, _scuff.SMatrix_NC_set)
    __swig_setmethods__["nnz"] = _scuff.SMatrix_nnz_set
    __swig_getmethods__["nnz"] = _scuff.SMatrix_nnz_get
    if _newclass:nnz = _swig_property(_scuff.SMatrix_nnz_get, _scuff.SMatrix_nnz_set)
    __swig_setmethods__["nnz_alloc"] = _scuff.SMatrix_nnz_alloc_set
    __swig_getmethods__["nnz_alloc"] = _scuff.SMatrix_nnz_alloc_get
    if _newclass:nnz_alloc = _swig_property(_scuff.SMatrix_nnz_alloc_get, _scuff.SMatrix_nnz_alloc_set)
    __swig_setmethods__["RealComplex"] = _scuff.SMatrix_RealComplex_set
    __swig_getmethods__["RealComplex"] = _scuff.SMatrix_RealComplex_get
    if _newclass:RealComplex = _swig_property(_scuff.SMatrix_RealComplex_get, _scuff.SMatrix_RealComplex_set)
    __swig_setmethods__["cur_nr"] = _scuff.SMatrix_cur_nr_set
    __swig_getmethods__["cur_nr"] = _scuff.SMatrix_cur_nr_get
    if _newclass:cur_nr = _swig_property(_scuff.SMatrix_cur_nr_get, _scuff.SMatrix_cur_nr_set)
    __swig_setmethods__["RowStart"] = _scuff.SMatrix_RowStart_set
    __swig_getmethods__["RowStart"] = _scuff.SMatrix_RowStart_get
    if _newclass:RowStart = _swig_property(_scuff.SMatrix_RowStart_get, _scuff.SMatrix_RowStart_set)
    __swig_setmethods__["DM"] = _scuff.SMatrix_DM_set
    __swig_getmethods__["DM"] = _scuff.SMatrix_DM_get
    if _newclass:DM = _swig_property(_scuff.SMatrix_DM_get, _scuff.SMatrix_DM_set)
    __swig_setmethods__["ZM"] = _scuff.SMatrix_ZM_set
    __swig_getmethods__["ZM"] = _scuff.SMatrix_ZM_get
    if _newclass:ZM = _swig_property(_scuff.SMatrix_ZM_get, _scuff.SMatrix_ZM_set)
    __swig_setmethods__["ColIndices"] = _scuff.SMatrix_ColIndices_set
    __swig_getmethods__["ColIndices"] = _scuff.SMatrix_ColIndices_get
    if _newclass:ColIndices = _swig_property(_scuff.SMatrix_ColIndices_get, _scuff.SMatrix_ColIndices_set)
SMatrix_swigregister = _scuff.SMatrix_swigregister
SMatrix_swigregister(SMatrix)

MP_VACUUM = _scuff.MP_VACUUM
MP_PEC = _scuff.MP_PEC
MP_CONSTANT = _scuff.MP_CONSTANT
MP_INTERP = _scuff.MP_INTERP
MP_PARSED = _scuff.MP_PARSED
MP_OTHER = _scuff.MP_OTHER
class MatProp(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MatProp, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MatProp, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _scuff.new_MatProp(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _scuff.delete_MatProp
    __del__ = lambda self : None;
    __swig_getmethods__["SetFreqUnit"] = lambda x: _scuff.MatProp_SetFreqUnit
    if _newclass:SetFreqUnit = staticmethod(_scuff.MatProp_SetFreqUnit)
    __swig_getmethods__["SetLengthUnit"] = lambda x: _scuff.MatProp_SetLengthUnit
    if _newclass:SetLengthUnit = staticmethod(_scuff.MatProp_SetLengthUnit)
    def GetEpsMu(self, *args): return _scuff.MatProp_GetEpsMu(self, *args)
    def GetEps(self, *args): return _scuff.MatProp_GetEps(self, *args)
    def GetMu(self, *args): return _scuff.MatProp_GetMu(self, *args)
    def GetRefractiveIndex(self, *args): return _scuff.MatProp_GetRefractiveIndex(self, *args)
    def SetEpsMu(self, *args): return _scuff.MatProp_SetEpsMu(self, *args)
    def SetEps(self, *args): return _scuff.MatProp_SetEps(self, *args)
    def IsPEC(self): return _scuff.MatProp_IsPEC(self)
    def Zero(self): return _scuff.MatProp_Zero(self)
    def UnZero(self): return _scuff.MatProp_UnZero(self)
    __swig_setmethods__["ErrMsg"] = _scuff.MatProp_ErrMsg_set
    __swig_getmethods__["ErrMsg"] = _scuff.MatProp_ErrMsg_get
    if _newclass:ErrMsg = _swig_property(_scuff.MatProp_ErrMsg_get, _scuff.MatProp_ErrMsg_set)
    def InitMatProp(self, *args): return _scuff.MatProp_InitMatProp(self, *args)
    def ReadInterpolationTable(self, *args): return _scuff.MatProp_ReadInterpolationTable(self, *args)
    def CreateUserDefinedMaterial(self, *args): return _scuff.MatProp_CreateUserDefinedMaterial(self, *args)
    def ReadMaterialFromFile(self, *args): return _scuff.MatProp_ReadMaterialFromFile(self, *args)
    def ParseMaterialSectionInFile(self, *args): return _scuff.MatProp_ParseMaterialSectionInFile(self, *args)
    def GetEpsMu_Parsed(self, *args): return _scuff.MatProp_GetEpsMu_Parsed(self, *args)
    __swig_setmethods__["Type"] = _scuff.MatProp_Type_set
    __swig_getmethods__["Type"] = _scuff.MatProp_Type_get
    if _newclass:Type = _swig_property(_scuff.MatProp_Type_get, _scuff.MatProp_Type_set)
    __swig_setmethods__["Zeroed"] = _scuff.MatProp_Zeroed_set
    __swig_getmethods__["Zeroed"] = _scuff.MatProp_Zeroed_get
    if _newclass:Zeroed = _swig_property(_scuff.MatProp_Zeroed_get, _scuff.MatProp_Zeroed_set)
    __swig_setmethods__["Name"] = _scuff.MatProp_Name_set
    __swig_getmethods__["Name"] = _scuff.MatProp_Name_get
    if _newclass:Name = _swig_property(_scuff.MatProp_Name_get, _scuff.MatProp_Name_set)
    __swig_setmethods__["Eps"] = _scuff.MatProp_Eps_set
    __swig_getmethods__["Eps"] = _scuff.MatProp_Eps_get
    if _newclass:Eps = _swig_property(_scuff.MatProp_Eps_get, _scuff.MatProp_Eps_set)
    __swig_setmethods__["Mu"] = _scuff.MatProp_Mu_set
    __swig_getmethods__["Mu"] = _scuff.MatProp_Mu_get
    if _newclass:Mu = _swig_property(_scuff.MatProp_Mu_get, _scuff.MatProp_Mu_set)
    __swig_setmethods__["InterpReal"] = _scuff.MatProp_InterpReal_set
    __swig_getmethods__["InterpReal"] = _scuff.MatProp_InterpReal_get
    if _newclass:InterpReal = _swig_property(_scuff.MatProp_InterpReal_get, _scuff.MatProp_InterpReal_set)
    __swig_setmethods__["InterpImag"] = _scuff.MatProp_InterpImag_set
    __swig_getmethods__["InterpImag"] = _scuff.MatProp_InterpImag_get
    if _newclass:InterpImag = _swig_property(_scuff.MatProp_InterpImag_get, _scuff.MatProp_InterpImag_set)
    __swig_setmethods__["OwnsInterpolators"] = _scuff.MatProp_OwnsInterpolators_set
    __swig_getmethods__["OwnsInterpolators"] = _scuff.MatProp_OwnsInterpolators_get
    if _newclass:OwnsInterpolators = _swig_property(_scuff.MatProp_OwnsInterpolators_get, _scuff.MatProp_OwnsInterpolators_set)
    __swig_setmethods__["EpsExpression"] = _scuff.MatProp_EpsExpression_set
    __swig_getmethods__["EpsExpression"] = _scuff.MatProp_EpsExpression_get
    if _newclass:EpsExpression = _swig_property(_scuff.MatProp_EpsExpression_get, _scuff.MatProp_EpsExpression_set)
    __swig_setmethods__["MuExpression"] = _scuff.MatProp_MuExpression_set
    __swig_getmethods__["MuExpression"] = _scuff.MatProp_MuExpression_get
    if _newclass:MuExpression = _swig_property(_scuff.MatProp_MuExpression_get, _scuff.MatProp_MuExpression_set)
    __swig_setmethods__["OwnsExpressions"] = _scuff.MatProp_OwnsExpressions_set
    __swig_getmethods__["OwnsExpressions"] = _scuff.MatProp_OwnsExpressions_get
    if _newclass:OwnsExpressions = _swig_property(_scuff.MatProp_OwnsExpressions_get, _scuff.MatProp_OwnsExpressions_set)
    __swig_setmethods__["FreqUnit"] = _scuff.MatProp_FreqUnit_set
    __swig_getmethods__["FreqUnit"] = _scuff.MatProp_FreqUnit_get
    if _newclass:FreqUnit = _swig_property(_scuff.MatProp_FreqUnit_get, _scuff.MatProp_FreqUnit_set)
MatProp_swigregister = _scuff.MatProp_swigregister
MatProp_swigregister(MatProp)

def MatProp_SetFreqUnit(*args):
  return _scuff.MatProp_SetFreqUnit(*args)
MatProp_SetFreqUnit = _scuff.MatProp_SetFreqUnit

def MatProp_SetLengthUnit(*args):
  return _scuff.MatProp_SetLengthUnit(*args)
MatProp_SetLengthUnit = _scuff.MatProp_SetLengthUnit


def AddMaterialToMatPropDataBase(*args):
  return _scuff.AddMaterialToMatPropDataBase(*args)
AddMaterialToMatPropDataBase = _scuff.AddMaterialToMatPropDataBase
ZVAC = _scuff.ZVAC
class IncField(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, IncField, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, IncField, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_setmethods__["Omega"] = _scuff.IncField_Omega_set
    __swig_getmethods__["Omega"] = _scuff.IncField_Omega_get
    if _newclass:Omega = _swig_property(_scuff.IncField_Omega_get, _scuff.IncField_Omega_set)
    __swig_setmethods__["Eps"] = _scuff.IncField_Eps_set
    __swig_getmethods__["Eps"] = _scuff.IncField_Eps_get
    if _newclass:Eps = _swig_property(_scuff.IncField_Eps_get, _scuff.IncField_Eps_set)
    __swig_setmethods__["Mu"] = _scuff.IncField_Mu_set
    __swig_getmethods__["Mu"] = _scuff.IncField_Mu_get
    if _newclass:Mu = _swig_property(_scuff.IncField_Mu_get, _scuff.IncField_Mu_set)
    __swig_setmethods__["LDim"] = _scuff.IncField_LDim_set
    __swig_getmethods__["LDim"] = _scuff.IncField_LDim_get
    if _newclass:LDim = _swig_property(_scuff.IncField_LDim_get, _scuff.IncField_LDim_set)
    __swig_setmethods__["LBV1"] = _scuff.IncField_LBV1_set
    __swig_getmethods__["LBV1"] = _scuff.IncField_LBV1_get
    if _newclass:LBV1 = _swig_property(_scuff.IncField_LBV1_get, _scuff.IncField_LBV1_set)
    __swig_setmethods__["LBV2"] = _scuff.IncField_LBV2_set
    __swig_getmethods__["LBV2"] = _scuff.IncField_LBV2_get
    if _newclass:LBV2 = _swig_property(_scuff.IncField_LBV2_get, _scuff.IncField_LBV2_set)
    __swig_setmethods__["LBV"] = _scuff.IncField_LBV_set
    __swig_getmethods__["LBV"] = _scuff.IncField_LBV_get
    if _newclass:LBV = _swig_property(_scuff.IncField_LBV_get, _scuff.IncField_LBV_set)
    __swig_setmethods__["kBloch"] = _scuff.IncField_kBloch_set
    __swig_getmethods__["kBloch"] = _scuff.IncField_kBloch_get
    if _newclass:kBloch = _swig_property(_scuff.IncField_kBloch_get, _scuff.IncField_kBloch_set)
    __swig_setmethods__["Next"] = _scuff.IncField_Next_set
    __swig_getmethods__["Next"] = _scuff.IncField_Next_get
    if _newclass:Next = _swig_property(_scuff.IncField_Next_get, _scuff.IncField_Next_set)
    __swig_setmethods__["RegionLabel"] = _scuff.IncField_RegionLabel_set
    __swig_getmethods__["RegionLabel"] = _scuff.IncField_RegionLabel_get
    if _newclass:RegionLabel = _swig_property(_scuff.IncField_RegionLabel_get, _scuff.IncField_RegionLabel_set)
    __swig_setmethods__["RegionIndex"] = _scuff.IncField_RegionIndex_set
    __swig_getmethods__["RegionIndex"] = _scuff.IncField_RegionIndex_get
    if _newclass:RegionIndex = _swig_property(_scuff.IncField_RegionIndex_get, _scuff.IncField_RegionIndex_set)
    __swig_destroy__ = _scuff.delete_IncField
    __del__ = lambda self : None;
    def SetFrequency(self, *args): return _scuff.IncField_SetFrequency(self, *args)
    def SetFrequencyAndEpsMu(self, *args): return _scuff.IncField_SetFrequencyAndEpsMu(self, *args)
    def SetRegionLabel(self, Label=None): return _scuff.IncField_SetRegionLabel(self, Label)
    def SetLattice(self, *args): return _scuff.IncField_SetLattice(self, *args)
    def SetkBloch(self, *args): return _scuff.IncField_SetkBloch(self, *args)
    def SetObjectLabel(self, *args): return _scuff.IncField_SetObjectLabel(self, *args)
    def GetSourcePoint(self, *args): return _scuff.IncField_GetSourcePoint(self, *args)
    def GetFields(self, *args): return _scuff.IncField_GetFields(self, *args)
    def GetTotalFields(self, *args): return _scuff.IncField_GetTotalFields(self, *args)
IncField_swigregister = _scuff.IncField_swigregister
IncField_swigregister(IncField)


def DeleteIncFieldChain(*args):
  return _scuff.DeleteIncFieldChain(*args)
DeleteIncFieldChain = _scuff.DeleteIncFieldChain
class PlaneWave(IncField):
    __swig_setmethods__ = {}
    for _s in [IncField]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PlaneWave, name, value)
    __swig_getmethods__ = {}
    for _s in [IncField]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, PlaneWave, name)
    __repr__ = _swig_repr
    __swig_setmethods__["E0"] = _scuff.PlaneWave_E0_set
    __swig_getmethods__["E0"] = _scuff.PlaneWave_E0_get
    if _newclass:E0 = _swig_property(_scuff.PlaneWave_E0_get, _scuff.PlaneWave_E0_set)
    __swig_setmethods__["nHat"] = _scuff.PlaneWave_nHat_set
    __swig_getmethods__["nHat"] = _scuff.PlaneWave_nHat_get
    if _newclass:nHat = _swig_property(_scuff.PlaneWave_nHat_get, _scuff.PlaneWave_nHat_set)
    def __init__(self, *args): 
        this = _scuff.new_PlaneWave(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _scuff.delete_PlaneWave
    __del__ = lambda self : None;
    def SetE0(self, *args): return _scuff.PlaneWave_SetE0(self, *args)
    def SetnHat(self, *args): return _scuff.PlaneWave_SetnHat(self, *args)
    def GetFields(self, *args): return _scuff.PlaneWave_GetFields(self, *args)
PlaneWave_swigregister = _scuff.PlaneWave_swigregister
PlaneWave_swigregister(PlaneWave)

LIF_ELECTRIC_DIPOLE = _scuff.LIF_ELECTRIC_DIPOLE
LIF_MAGNETIC_DIPOLE = _scuff.LIF_MAGNETIC_DIPOLE
class PointSource(IncField):
    __swig_setmethods__ = {}
    for _s in [IncField]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PointSource, name, value)
    __swig_getmethods__ = {}
    for _s in [IncField]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, PointSource, name)
    __repr__ = _swig_repr
    __swig_setmethods__["X0"] = _scuff.PointSource_X0_set
    __swig_getmethods__["X0"] = _scuff.PointSource_X0_get
    if _newclass:X0 = _swig_property(_scuff.PointSource_X0_get, _scuff.PointSource_X0_set)
    __swig_setmethods__["P"] = _scuff.PointSource_P_set
    __swig_getmethods__["P"] = _scuff.PointSource_P_get
    if _newclass:P = _swig_property(_scuff.PointSource_P_get, _scuff.PointSource_P_set)
    __swig_setmethods__["Type"] = _scuff.PointSource_Type_set
    __swig_getmethods__["Type"] = _scuff.PointSource_Type_get
    if _newclass:Type = _swig_property(_scuff.PointSource_Type_get, _scuff.PointSource_Type_set)
    def __init__(self, *args): 
        this = _scuff.new_PointSource(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _scuff.delete_PointSource
    __del__ = lambda self : None;
    def SetX0(self, *args): return _scuff.PointSource_SetX0(self, *args)
    def SetP(self, *args): return _scuff.PointSource_SetP(self, *args)
    def SetType(self, *args): return _scuff.PointSource_SetType(self, *args)
    def GetFields(self, *args): return _scuff.PointSource_GetFields(self, *args)
    def GetFields_Periodic(self, *args): return _scuff.PointSource_GetFields_Periodic(self, *args)
    def GetSourcePoint(self, *args): return _scuff.PointSource_GetSourcePoint(self, *args)
PointSource_swigregister = _scuff.PointSource_swigregister
PointSource_swigregister(PointSource)

class GaussianBeam(IncField):
    __swig_setmethods__ = {}
    for _s in [IncField]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, GaussianBeam, name, value)
    __swig_getmethods__ = {}
    for _s in [IncField]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, GaussianBeam, name)
    __repr__ = _swig_repr
    __swig_setmethods__["X0"] = _scuff.GaussianBeam_X0_set
    __swig_getmethods__["X0"] = _scuff.GaussianBeam_X0_get
    if _newclass:X0 = _swig_property(_scuff.GaussianBeam_X0_get, _scuff.GaussianBeam_X0_set)
    __swig_setmethods__["KProp"] = _scuff.GaussianBeam_KProp_set
    __swig_getmethods__["KProp"] = _scuff.GaussianBeam_KProp_get
    if _newclass:KProp = _swig_property(_scuff.GaussianBeam_KProp_get, _scuff.GaussianBeam_KProp_set)
    __swig_setmethods__["E0"] = _scuff.GaussianBeam_E0_set
    __swig_getmethods__["E0"] = _scuff.GaussianBeam_E0_get
    if _newclass:E0 = _swig_property(_scuff.GaussianBeam_E0_get, _scuff.GaussianBeam_E0_set)
    __swig_setmethods__["W0"] = _scuff.GaussianBeam_W0_set
    __swig_getmethods__["W0"] = _scuff.GaussianBeam_W0_get
    if _newclass:W0 = _swig_property(_scuff.GaussianBeam_W0_get, _scuff.GaussianBeam_W0_set)
    def __init__(self, *args): 
        this = _scuff.new_GaussianBeam(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _scuff.delete_GaussianBeam
    __del__ = lambda self : None;
    def SetX0(self, *args): return _scuff.GaussianBeam_SetX0(self, *args)
    def SetKProp(self, *args): return _scuff.GaussianBeam_SetKProp(self, *args)
    def SetE0(self, *args): return _scuff.GaussianBeam_SetE0(self, *args)
    def SetW0(self, *args): return _scuff.GaussianBeam_SetW0(self, *args)
    def GetFields(self, *args): return _scuff.GaussianBeam_GetFields(self, *args)
    def TotalBeamFlux(self): return _scuff.GaussianBeam_TotalBeamFlux(self)
GaussianBeam_swigregister = _scuff.GaussianBeam_swigregister
GaussianBeam_swigregister(GaussianBeam)

class GTransformation(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GTransformation, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GTransformation, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _scuff.new_GTransformation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _scuff.delete_GTransformation
    __del__ = lambda self : None;
    def Reset(self): return _scuff.GTransformation_Reset(self)
    def Displace(self, *args): return _scuff.GTransformation_Displace(self, *args)
    def Rotate(self, *args): return _scuff.GTransformation_Rotate(self, *args)
    def Transform(self, *args): return _scuff.GTransformation_Transform(self, *args)
    def Invert(self): return _scuff.GTransformation_Invert(self)
    def Inverse(self): return _scuff.GTransformation_Inverse(self)
    def Parse(self, *args): return _scuff.GTransformation_Parse(self, *args)
    def __add__(self, *args): return _scuff.GTransformation___add__(self, *args)
    def __sub__(self, *args): return _scuff.GTransformation___sub__(self, *args)
    def __neg__(self): return _scuff.GTransformation___neg__(self)
    def Apply(self, *args): return _scuff.GTransformation_Apply(self, *args)
    def UnApply(self, *args): return _scuff.GTransformation_UnApply(self, *args)
    def ApplyRotation(self, *args): return _scuff.GTransformation_ApplyRotation(self, *args)
    def UnApplyRotation(self, *args): return _scuff.GTransformation_UnApplyRotation(self, *args)
    __swig_setmethods__["DX"] = _scuff.GTransformation_DX_set
    __swig_getmethods__["DX"] = _scuff.GTransformation_DX_get
    if _newclass:DX = _swig_property(_scuff.GTransformation_DX_get, _scuff.GTransformation_DX_set)
    __swig_setmethods__["M"] = _scuff.GTransformation_M_set
    __swig_getmethods__["M"] = _scuff.GTransformation_M_get
    if _newclass:M = _swig_property(_scuff.GTransformation_M_get, _scuff.GTransformation_M_set)
GTransformation_swigregister = _scuff.GTransformation_swigregister
GTransformation_swigregister(GTransformation)

class GTComplex(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GTComplex, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GTComplex, name)
    __repr__ = _swig_repr
    __swig_setmethods__["Tag"] = _scuff.GTComplex_Tag_set
    __swig_getmethods__["Tag"] = _scuff.GTComplex_Tag_get
    if _newclass:Tag = _swig_property(_scuff.GTComplex_Tag_get, _scuff.GTComplex_Tag_set)
    __swig_setmethods__["NumSurfacesAffected"] = _scuff.GTComplex_NumSurfacesAffected_set
    __swig_getmethods__["NumSurfacesAffected"] = _scuff.GTComplex_NumSurfacesAffected_get
    if _newclass:NumSurfacesAffected = _swig_property(_scuff.GTComplex_NumSurfacesAffected_get, _scuff.GTComplex_NumSurfacesAffected_set)
    __swig_setmethods__["SurfaceLabel"] = _scuff.GTComplex_SurfaceLabel_set
    __swig_getmethods__["SurfaceLabel"] = _scuff.GTComplex_SurfaceLabel_get
    if _newclass:SurfaceLabel = _swig_property(_scuff.GTComplex_SurfaceLabel_get, _scuff.GTComplex_SurfaceLabel_set)
    __swig_setmethods__["GT"] = _scuff.GTComplex_GT_set
    __swig_getmethods__["GT"] = _scuff.GTComplex_GT_get
    if _newclass:GT = _swig_property(_scuff.GTComplex_GT_get, _scuff.GTComplex_GT_set)
    def __init__(self): 
        this = _scuff.new_GTComplex()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _scuff.delete_GTComplex
    __del__ = lambda self : None;
GTComplex_swigregister = _scuff.GTComplex_swigregister
GTComplex_swigregister(GTComplex)


def CreateDefaultGTComplex():
  return _scuff.CreateDefaultGTComplex()
CreateDefaultGTComplex = _scuff.CreateDefaultGTComplex

def ReadTransFile(*args):
  return _scuff.ReadTransFile(*args)
ReadTransFile = _scuff.ReadTransFile
SCUFF_FIELDGRID_H = _scuff.SCUFF_FIELDGRID_H
class FieldFunc(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, FieldFunc, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, FieldFunc, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    def IsReal(self): return _scuff.FieldFunc_IsReal(self)
    def Eval(self, *args): return _scuff.FieldFunc_Eval(self, *args)
    __swig_destroy__ = _scuff.delete_FieldFunc
    __del__ = lambda self : None;
FieldFunc_swigregister = _scuff.FieldFunc_swigregister
FieldFunc_swigregister(FieldFunc)

class ParsedFieldFunc(FieldFunc):
    __swig_setmethods__ = {}
    for _s in [FieldFunc]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ParsedFieldFunc, name, value)
    __swig_getmethods__ = {}
    for _s in [FieldFunc]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ParsedFieldFunc, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _scuff.new_ParsedFieldFunc(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _scuff.delete_ParsedFieldFunc
    __del__ = lambda self : None;
    def Eval(self, *args): return _scuff.ParsedFieldFunc_Eval(self, *args)
    def IsReal(self): return _scuff.ParsedFieldFunc_IsReal(self)
    def String(self): return _scuff.ParsedFieldFunc_String(self)
ParsedFieldFunc_swigregister = _scuff.ParsedFieldFunc_swigregister
ParsedFieldFunc_swigregister(ParsedFieldFunc)

POYNTINGx_EXPR = _scuff.POYNTINGx_EXPR
POYNTINGy_EXPR = _scuff.POYNTINGy_EXPR
POYNTINGz_EXPR = _scuff.POYNTINGz_EXPR
POYNTING_EXPR = _scuff.POYNTING_EXPR
ENERGYDENSITY_EXPR = _scuff.ENERGYDENSITY_EXPR
E_ENERGYDENSITY_EXPR = _scuff.E_ENERGYDENSITY_EXPR
H_ENERGYDENSITY_EXPR = _scuff.H_ENERGYDENSITY_EXPR
ABSORPTION_EXPR = _scuff.ABSORPTION_EXPR
EMAG_EXPR = _scuff.EMAG_EXPR
EMAG2_EXPR = _scuff.EMAG2_EXPR
HMAG_EXPR = _scuff.HMAG_EXPR
HMAG2_EXPR = _scuff.HMAG2_EXPR
FORCEx_DENSITY_EXPR = _scuff.FORCEx_DENSITY_EXPR
FORCEy_DENSITY_EXPR = _scuff.FORCEy_DENSITY_EXPR
FORCEz_DENSITY_EXPR = _scuff.FORCEz_DENSITY_EXPR
FORCE_DENSITY_EXPR = _scuff.FORCE_DENSITY_EXPR
class SurfaceGrid(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SurfaceGrid, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SurfaceGrid, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_setmethods__["N1"] = _scuff.SurfaceGrid_N1_set
    __swig_getmethods__["N1"] = _scuff.SurfaceGrid_N1_get
    if _newclass:N1 = _swig_property(_scuff.SurfaceGrid_N1_get, _scuff.SurfaceGrid_N1_set)
    __swig_setmethods__["N2"] = _scuff.SurfaceGrid_N2_set
    __swig_getmethods__["N2"] = _scuff.SurfaceGrid_N2_get
    if _newclass:N2 = _swig_property(_scuff.SurfaceGrid_N2_get, _scuff.SurfaceGrid_N2_set)
    def AllocateGrid(self, *args): return _scuff.SurfaceGrid_AllocateGrid(self, *args)
    def GetPoint(self, *args): return _scuff.SurfaceGrid_GetPoint(self, *args)
    def Transform(self, *args): return _scuff.SurfaceGrid_Transform(self, *args)
    __swig_destroy__ = _scuff.delete_SurfaceGrid
    __del__ = lambda self : None;
SurfaceGrid_swigregister = _scuff.SurfaceGrid_swigregister
SurfaceGrid_swigregister(SurfaceGrid)

XDIR = _scuff.XDIR
YDIR = _scuff.YDIR
ZDIR = _scuff.ZDIR
class PlaneGrid(SurfaceGrid):
    __swig_setmethods__ = {}
    for _s in [SurfaceGrid]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PlaneGrid, name, value)
    __swig_getmethods__ = {}
    for _s in [SurfaceGrid]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, PlaneGrid, name)
    __repr__ = _swig_repr
    __swig_setmethods__["X0"] = _scuff.PlaneGrid_X0_set
    __swig_getmethods__["X0"] = _scuff.PlaneGrid_X0_get
    if _newclass:X0 = _swig_property(_scuff.PlaneGrid_X0_get, _scuff.PlaneGrid_X0_set)
    __swig_setmethods__["S1"] = _scuff.PlaneGrid_S1_set
    __swig_getmethods__["S1"] = _scuff.PlaneGrid_S1_get
    if _newclass:S1 = _swig_property(_scuff.PlaneGrid_S1_get, _scuff.PlaneGrid_S1_set)
    __swig_setmethods__["S2"] = _scuff.PlaneGrid_S2_set
    __swig_getmethods__["S2"] = _scuff.PlaneGrid_S2_get
    if _newclass:S2 = _swig_property(_scuff.PlaneGrid_S2_get, _scuff.PlaneGrid_S2_set)
    __swig_setmethods__["dA0"] = _scuff.PlaneGrid_dA0_set
    __swig_getmethods__["dA0"] = _scuff.PlaneGrid_dA0_get
    if _newclass:dA0 = _swig_property(_scuff.PlaneGrid_dA0_get, _scuff.PlaneGrid_dA0_set)
    def __init__(self, *args): 
        this = _scuff.new_PlaneGrid(*args)
        try: self.this.append(this)
        except: self.this = this
    def GetPoint(self, *args): return _scuff.PlaneGrid_GetPoint(self, *args)
    def Transform(self, *args): return _scuff.PlaneGrid_Transform(self, *args)
    __swig_destroy__ = _scuff.delete_PlaneGrid
    __del__ = lambda self : None;
PlaneGrid_swigregister = _scuff.PlaneGrid_swigregister
PlaneGrid_swigregister(PlaneGrid)

SCUFF_GENERALFREQ = _scuff.SCUFF_GENERALFREQ
SCUFF_PUREIMAGFREQ = _scuff.SCUFF_PUREIMAGFREQ
SCUFF_NOLOGGING = _scuff.SCUFF_NOLOGGING
SCUFF_TERSELOGGING = _scuff.SCUFF_TERSELOGGING
SCUFF_VERBOSELOGGING = _scuff.SCUFF_VERBOSELOGGING
SCUFF_VERBOSE2 = _scuff.SCUFF_VERBOSE2
MAXLDIM = _scuff.MAXLDIM
class RWGPanel(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, RWGPanel, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, RWGPanel, name)
    __repr__ = _swig_repr
    __swig_setmethods__["VI"] = _scuff.RWGPanel_VI_set
    __swig_getmethods__["VI"] = _scuff.RWGPanel_VI_get
    if _newclass:VI = _swig_property(_scuff.RWGPanel_VI_get, _scuff.RWGPanel_VI_set)
    __swig_setmethods__["EI"] = _scuff.RWGPanel_EI_set
    __swig_getmethods__["EI"] = _scuff.RWGPanel_EI_get
    if _newclass:EI = _swig_property(_scuff.RWGPanel_EI_get, _scuff.RWGPanel_EI_set)
    __swig_setmethods__["Centroid"] = _scuff.RWGPanel_Centroid_set
    __swig_getmethods__["Centroid"] = _scuff.RWGPanel_Centroid_get
    if _newclass:Centroid = _swig_property(_scuff.RWGPanel_Centroid_get, _scuff.RWGPanel_Centroid_set)
    __swig_setmethods__["ZHat"] = _scuff.RWGPanel_ZHat_set
    __swig_getmethods__["ZHat"] = _scuff.RWGPanel_ZHat_get
    if _newclass:ZHat = _swig_property(_scuff.RWGPanel_ZHat_get, _scuff.RWGPanel_ZHat_set)
    __swig_setmethods__["ZHatFlipped"] = _scuff.RWGPanel_ZHatFlipped_set
    __swig_getmethods__["ZHatFlipped"] = _scuff.RWGPanel_ZHatFlipped_get
    if _newclass:ZHatFlipped = _swig_property(_scuff.RWGPanel_ZHatFlipped_get, _scuff.RWGPanel_ZHatFlipped_set)
    __swig_setmethods__["Radius"] = _scuff.RWGPanel_Radius_set
    __swig_getmethods__["Radius"] = _scuff.RWGPanel_Radius_get
    if _newclass:Radius = _swig_property(_scuff.RWGPanel_Radius_get, _scuff.RWGPanel_Radius_set)
    __swig_setmethods__["Area"] = _scuff.RWGPanel_Area_set
    __swig_getmethods__["Area"] = _scuff.RWGPanel_Area_get
    if _newclass:Area = _swig_property(_scuff.RWGPanel_Area_get, _scuff.RWGPanel_Area_set)
    __swig_setmethods__["Index"] = _scuff.RWGPanel_Index_set
    __swig_getmethods__["Index"] = _scuff.RWGPanel_Index_get
    if _newclass:Index = _swig_property(_scuff.RWGPanel_Index_get, _scuff.RWGPanel_Index_set)
    def __init__(self): 
        this = _scuff.new_RWGPanel()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _scuff.delete_RWGPanel
    __del__ = lambda self : None;
RWGPanel_swigregister = _scuff.RWGPanel_swigregister
RWGPanel_swigregister(RWGPanel)

class RWGEdge(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, RWGEdge, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, RWGEdge, name)
    __repr__ = _swig_repr
    __swig_setmethods__["iV1"] = _scuff.RWGEdge_iV1_set
    __swig_getmethods__["iV1"] = _scuff.RWGEdge_iV1_get
    if _newclass:iV1 = _swig_property(_scuff.RWGEdge_iV1_get, _scuff.RWGEdge_iV1_set)
    __swig_setmethods__["iV2"] = _scuff.RWGEdge_iV2_set
    __swig_getmethods__["iV2"] = _scuff.RWGEdge_iV2_get
    if _newclass:iV2 = _swig_property(_scuff.RWGEdge_iV2_get, _scuff.RWGEdge_iV2_set)
    __swig_setmethods__["iQP"] = _scuff.RWGEdge_iQP_set
    __swig_getmethods__["iQP"] = _scuff.RWGEdge_iQP_get
    if _newclass:iQP = _swig_property(_scuff.RWGEdge_iQP_get, _scuff.RWGEdge_iQP_set)
    __swig_setmethods__["iQM"] = _scuff.RWGEdge_iQM_set
    __swig_getmethods__["iQM"] = _scuff.RWGEdge_iQM_get
    if _newclass:iQM = _swig_property(_scuff.RWGEdge_iQM_get, _scuff.RWGEdge_iQM_set)
    __swig_setmethods__["Centroid"] = _scuff.RWGEdge_Centroid_set
    __swig_getmethods__["Centroid"] = _scuff.RWGEdge_Centroid_get
    if _newclass:Centroid = _swig_property(_scuff.RWGEdge_Centroid_get, _scuff.RWGEdge_Centroid_set)
    __swig_setmethods__["Length"] = _scuff.RWGEdge_Length_set
    __swig_getmethods__["Length"] = _scuff.RWGEdge_Length_get
    if _newclass:Length = _swig_property(_scuff.RWGEdge_Length_get, _scuff.RWGEdge_Length_set)
    __swig_setmethods__["Radius"] = _scuff.RWGEdge_Radius_set
    __swig_getmethods__["Radius"] = _scuff.RWGEdge_Radius_get
    if _newclass:Radius = _swig_property(_scuff.RWGEdge_Radius_get, _scuff.RWGEdge_Radius_set)
    __swig_setmethods__["iPPanel"] = _scuff.RWGEdge_iPPanel_set
    __swig_getmethods__["iPPanel"] = _scuff.RWGEdge_iPPanel_get
    if _newclass:iPPanel = _swig_property(_scuff.RWGEdge_iPPanel_get, _scuff.RWGEdge_iPPanel_set)
    __swig_setmethods__["iMPanel"] = _scuff.RWGEdge_iMPanel_set
    __swig_getmethods__["iMPanel"] = _scuff.RWGEdge_iMPanel_get
    if _newclass:iMPanel = _swig_property(_scuff.RWGEdge_iMPanel_get, _scuff.RWGEdge_iMPanel_set)
    __swig_setmethods__["PIndex"] = _scuff.RWGEdge_PIndex_set
    __swig_getmethods__["PIndex"] = _scuff.RWGEdge_PIndex_get
    if _newclass:PIndex = _swig_property(_scuff.RWGEdge_PIndex_get, _scuff.RWGEdge_PIndex_set)
    __swig_setmethods__["MIndex"] = _scuff.RWGEdge_MIndex_set
    __swig_getmethods__["MIndex"] = _scuff.RWGEdge_MIndex_get
    if _newclass:MIndex = _swig_property(_scuff.RWGEdge_MIndex_get, _scuff.RWGEdge_MIndex_set)
    __swig_setmethods__["Index"] = _scuff.RWGEdge_Index_set
    __swig_getmethods__["Index"] = _scuff.RWGEdge_Index_get
    if _newclass:Index = _swig_property(_scuff.RWGEdge_Index_get, _scuff.RWGEdge_Index_set)
    __swig_setmethods__["Next"] = _scuff.RWGEdge_Next_set
    __swig_getmethods__["Next"] = _scuff.RWGEdge_Next_get
    if _newclass:Next = _swig_property(_scuff.RWGEdge_Next_get, _scuff.RWGEdge_Next_set)
    def __init__(self): 
        this = _scuff.new_RWGEdge()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _scuff.delete_RWGEdge
    __del__ = lambda self : None;
RWGEdge_swigregister = _scuff.RWGEdge_swigregister
RWGEdge_swigregister(RWGEdge)


def kdtri_destroy(*args):
  return _scuff.kdtri_destroy(*args)
kdtri_destroy = _scuff.kdtri_destroy

def kdtri_maxdepth(*args):
  return _scuff.kdtri_maxdepth(*args)
kdtri_maxdepth = _scuff.kdtri_maxdepth

def kdtri_maxleaf(*args):
  return _scuff.kdtri_maxleaf(*args)
kdtri_maxleaf = _scuff.kdtri_maxleaf

def kdtri_meandepth(*args):
  return _scuff.kdtri_meandepth(*args)
kdtri_meandepth = _scuff.kdtri_meandepth

def kdtri_meanleaf(*args):
  return _scuff.kdtri_meanleaf(*args)
kdtri_meanleaf = _scuff.kdtri_meanleaf
class RWGSurface(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, RWGSurface, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, RWGSurface, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _scuff.new_RWGSurface(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _scuff.delete_RWGSurface
    __del__ = lambda self : None;
    def GetOverlap(self, *args): return _scuff.RWGSurface_GetOverlap(self, *args)
    def GetOverlaps(self, *args): return _scuff.RWGSurface_GetOverlaps(self, *args)
    def Transform(self, *args): return _scuff.RWGSurface_Transform(self, *args)
    def UnTransform(self): return _scuff.RWGSurface_UnTransform(self)
    def Contains(self, *args): return _scuff.RWGSurface_Contains(self, *args)
    def WriteGPMesh(self, *args): return _scuff.RWGSurface_WriteGPMesh(self, *args)
    def WritePPMesh(self, *args): return _scuff.RWGSurface_WritePPMesh(self, *args)
    def WritePPMeshLabels(self, *args): return _scuff.RWGSurface_WritePPMeshLabels(self, *args)
    def PlotScalarDensity(self, *args): return _scuff.RWGSurface_PlotScalarDensity(self, *args)
    __swig_setmethods__["RegionLabels"] = _scuff.RWGSurface_RegionLabels_set
    __swig_getmethods__["RegionLabels"] = _scuff.RWGSurface_RegionLabels_get
    if _newclass:RegionLabels = _swig_property(_scuff.RWGSurface_RegionLabels_get, _scuff.RWGSurface_RegionLabels_set)
    __swig_setmethods__["RegionIndices"] = _scuff.RWGSurface_RegionIndices_set
    __swig_getmethods__["RegionIndices"] = _scuff.RWGSurface_RegionIndices_get
    if _newclass:RegionIndices = _swig_property(_scuff.RWGSurface_RegionIndices_get, _scuff.RWGSurface_RegionIndices_set)
    __swig_setmethods__["IsPEC"] = _scuff.RWGSurface_IsPEC_set
    __swig_getmethods__["IsPEC"] = _scuff.RWGSurface_IsPEC_get
    if _newclass:IsPEC = _swig_property(_scuff.RWGSurface_IsPEC_get, _scuff.RWGSurface_IsPEC_set)
    __swig_setmethods__["IsObject"] = _scuff.RWGSurface_IsObject_set
    __swig_getmethods__["IsObject"] = _scuff.RWGSurface_IsObject_get
    if _newclass:IsObject = _swig_property(_scuff.RWGSurface_IsObject_get, _scuff.RWGSurface_IsObject_set)
    __swig_setmethods__["Vertices"] = _scuff.RWGSurface_Vertices_set
    __swig_getmethods__["Vertices"] = _scuff.RWGSurface_Vertices_get
    if _newclass:Vertices = _swig_property(_scuff.RWGSurface_Vertices_get, _scuff.RWGSurface_Vertices_set)
    __swig_setmethods__["Panels"] = _scuff.RWGSurface_Panels_set
    __swig_getmethods__["Panels"] = _scuff.RWGSurface_Panels_get
    if _newclass:Panels = _swig_property(_scuff.RWGSurface_Panels_get, _scuff.RWGSurface_Panels_set)
    __swig_setmethods__["Edges"] = _scuff.RWGSurface_Edges_set
    __swig_getmethods__["Edges"] = _scuff.RWGSurface_Edges_get
    if _newclass:Edges = _swig_property(_scuff.RWGSurface_Edges_get, _scuff.RWGSurface_Edges_set)
    __swig_setmethods__["ExteriorEdges"] = _scuff.RWGSurface_ExteriorEdges_set
    __swig_getmethods__["ExteriorEdges"] = _scuff.RWGSurface_ExteriorEdges_get
    if _newclass:ExteriorEdges = _swig_property(_scuff.RWGSurface_ExteriorEdges_get, _scuff.RWGSurface_ExteriorEdges_set)
    __swig_setmethods__["IsClosed"] = _scuff.RWGSurface_IsClosed_set
    __swig_getmethods__["IsClosed"] = _scuff.RWGSurface_IsClosed_get
    if _newclass:IsClosed = _swig_property(_scuff.RWGSurface_IsClosed_get, _scuff.RWGSurface_IsClosed_set)
    __swig_setmethods__["RMax"] = _scuff.RWGSurface_RMax_set
    __swig_getmethods__["RMax"] = _scuff.RWGSurface_RMax_get
    if _newclass:RMax = _swig_property(_scuff.RWGSurface_RMax_get, _scuff.RWGSurface_RMax_set)
    __swig_setmethods__["RMin"] = _scuff.RWGSurface_RMin_set
    __swig_getmethods__["RMin"] = _scuff.RWGSurface_RMin_get
    if _newclass:RMin = _swig_property(_scuff.RWGSurface_RMin_get, _scuff.RWGSurface_RMin_set)
    __swig_setmethods__["tolVecClose"] = _scuff.RWGSurface_tolVecClose_set
    __swig_getmethods__["tolVecClose"] = _scuff.RWGSurface_tolVecClose_get
    if _newclass:tolVecClose = _swig_property(_scuff.RWGSurface_tolVecClose_get, _scuff.RWGSurface_tolVecClose_set)
    __swig_setmethods__["NumVertices"] = _scuff.RWGSurface_NumVertices_set
    __swig_getmethods__["NumVertices"] = _scuff.RWGSurface_NumVertices_get
    if _newclass:NumVertices = _swig_property(_scuff.RWGSurface_NumVertices_get, _scuff.RWGSurface_NumVertices_set)
    __swig_setmethods__["NumInteriorVertices"] = _scuff.RWGSurface_NumInteriorVertices_set
    __swig_getmethods__["NumInteriorVertices"] = _scuff.RWGSurface_NumInteriorVertices_get
    if _newclass:NumInteriorVertices = _swig_property(_scuff.RWGSurface_NumInteriorVertices_get, _scuff.RWGSurface_NumInteriorVertices_set)
    __swig_setmethods__["NumRefPts"] = _scuff.RWGSurface_NumRefPts_set
    __swig_getmethods__["NumRefPts"] = _scuff.RWGSurface_NumRefPts_get
    if _newclass:NumRefPts = _swig_property(_scuff.RWGSurface_NumRefPts_get, _scuff.RWGSurface_NumRefPts_set)
    __swig_setmethods__["NumTotalEdges"] = _scuff.RWGSurface_NumTotalEdges_set
    __swig_getmethods__["NumTotalEdges"] = _scuff.RWGSurface_NumTotalEdges_get
    if _newclass:NumTotalEdges = _swig_property(_scuff.RWGSurface_NumTotalEdges_get, _scuff.RWGSurface_NumTotalEdges_set)
    __swig_setmethods__["NumEdges"] = _scuff.RWGSurface_NumEdges_set
    __swig_getmethods__["NumEdges"] = _scuff.RWGSurface_NumEdges_get
    if _newclass:NumEdges = _swig_property(_scuff.RWGSurface_NumEdges_get, _scuff.RWGSurface_NumEdges_set)
    __swig_setmethods__["NumExteriorEdges"] = _scuff.RWGSurface_NumExteriorEdges_set
    __swig_getmethods__["NumExteriorEdges"] = _scuff.RWGSurface_NumExteriorEdges_get
    if _newclass:NumExteriorEdges = _swig_property(_scuff.RWGSurface_NumExteriorEdges_get, _scuff.RWGSurface_NumExteriorEdges_set)
    __swig_setmethods__["NumBFs"] = _scuff.RWGSurface_NumBFs_set
    __swig_getmethods__["NumBFs"] = _scuff.RWGSurface_NumBFs_get
    if _newclass:NumBFs = _swig_property(_scuff.RWGSurface_NumBFs_get, _scuff.RWGSurface_NumBFs_set)
    __swig_setmethods__["NumPanels"] = _scuff.RWGSurface_NumPanels_set
    __swig_getmethods__["NumPanels"] = _scuff.RWGSurface_NumPanels_get
    if _newclass:NumPanels = _swig_property(_scuff.RWGSurface_NumPanels_get, _scuff.RWGSurface_NumPanels_set)
    __swig_setmethods__["NumBCs"] = _scuff.RWGSurface_NumBCs_set
    __swig_getmethods__["NumBCs"] = _scuff.RWGSurface_NumBCs_get
    if _newclass:NumBCs = _swig_property(_scuff.RWGSurface_NumBCs_get, _scuff.RWGSurface_NumBCs_set)
    __swig_setmethods__["Index"] = _scuff.RWGSurface_Index_set
    __swig_getmethods__["Index"] = _scuff.RWGSurface_Index_get
    if _newclass:Index = _swig_property(_scuff.RWGSurface_Index_get, _scuff.RWGSurface_Index_set)
    __swig_setmethods__["WhichBC"] = _scuff.RWGSurface_WhichBC_set
    __swig_getmethods__["WhichBC"] = _scuff.RWGSurface_WhichBC_get
    if _newclass:WhichBC = _swig_property(_scuff.RWGSurface_WhichBC_get, _scuff.RWGSurface_WhichBC_set)
    __swig_setmethods__["NumBCEdges"] = _scuff.RWGSurface_NumBCEdges_set
    __swig_getmethods__["NumBCEdges"] = _scuff.RWGSurface_NumBCEdges_get
    if _newclass:NumBCEdges = _swig_property(_scuff.RWGSurface_NumBCEdges_get, _scuff.RWGSurface_NumBCEdges_set)
    __swig_setmethods__["BCEdges"] = _scuff.RWGSurface_BCEdges_set
    __swig_getmethods__["BCEdges"] = _scuff.RWGSurface_BCEdges_get
    if _newclass:BCEdges = _swig_property(_scuff.RWGSurface_BCEdges_get, _scuff.RWGSurface_BCEdges_set)
    __swig_setmethods__["NumRedundantVertices"] = _scuff.RWGSurface_NumRedundantVertices_set
    __swig_getmethods__["NumRedundantVertices"] = _scuff.RWGSurface_NumRedundantVertices_get
    if _newclass:NumRedundantVertices = _swig_property(_scuff.RWGSurface_NumRedundantVertices_get, _scuff.RWGSurface_NumRedundantVertices_set)
    __swig_setmethods__["MeshFileName"] = _scuff.RWGSurface_MeshFileName_set
    __swig_getmethods__["MeshFileName"] = _scuff.RWGSurface_MeshFileName_get
    if _newclass:MeshFileName = _swig_property(_scuff.RWGSurface_MeshFileName_get, _scuff.RWGSurface_MeshFileName_set)
    __swig_setmethods__["MeshTag"] = _scuff.RWGSurface_MeshTag_set
    __swig_getmethods__["MeshTag"] = _scuff.RWGSurface_MeshTag_get
    if _newclass:MeshTag = _swig_property(_scuff.RWGSurface_MeshTag_get, _scuff.RWGSurface_MeshTag_set)
    __swig_setmethods__["Label"] = _scuff.RWGSurface_Label_set
    __swig_getmethods__["Label"] = _scuff.RWGSurface_Label_get
    if _newclass:Label = _swig_property(_scuff.RWGSurface_Label_get, _scuff.RWGSurface_Label_set)
    __swig_setmethods__["kdPanels"] = _scuff.RWGSurface_kdPanels_set
    __swig_getmethods__["kdPanels"] = _scuff.RWGSurface_kdPanels_get
    if _newclass:kdPanels = _swig_property(_scuff.RWGSurface_kdPanels_get, _scuff.RWGSurface_kdPanels_set)
    def InitkdPanels(self, reinit=False, LogLevel=0): return _scuff.RWGSurface_InitkdPanels(self, reinit, LogLevel)
    __swig_setmethods__["OTGT"] = _scuff.RWGSurface_OTGT_set
    __swig_getmethods__["OTGT"] = _scuff.RWGSurface_OTGT_get
    if _newclass:OTGT = _swig_property(_scuff.RWGSurface_OTGT_get, _scuff.RWGSurface_OTGT_set)
    __swig_setmethods__["GT"] = _scuff.RWGSurface_GT_set
    __swig_getmethods__["GT"] = _scuff.RWGSurface_GT_get
    if _newclass:GT = _swig_property(_scuff.RWGSurface_GT_get, _scuff.RWGSurface_GT_set)
    __swig_setmethods__["SurfaceSigma"] = _scuff.RWGSurface_SurfaceSigma_set
    __swig_getmethods__["SurfaceSigma"] = _scuff.RWGSurface_SurfaceSigma_get
    if _newclass:SurfaceSigma = _swig_property(_scuff.RWGSurface_SurfaceSigma_get, _scuff.RWGSurface_SurfaceSigma_set)
    __swig_setmethods__["SurfaceSigmaMP"] = _scuff.RWGSurface_SurfaceSigmaMP_set
    __swig_getmethods__["SurfaceSigmaMP"] = _scuff.RWGSurface_SurfaceSigmaMP_get
    if _newclass:SurfaceSigmaMP = _swig_property(_scuff.RWGSurface_SurfaceSigmaMP_get, _scuff.RWGSurface_SurfaceSigmaMP_set)
    __swig_setmethods__["ErrMsg"] = _scuff.RWGSurface_ErrMsg_set
    __swig_getmethods__["ErrMsg"] = _scuff.RWGSurface_ErrMsg_get
    if _newclass:ErrMsg = _swig_property(_scuff.RWGSurface_ErrMsg_get, _scuff.RWGSurface_ErrMsg_set)
    __swig_setmethods__["MaterialRegionsLineNum"] = _scuff.RWGSurface_MaterialRegionsLineNum_set
    __swig_getmethods__["MaterialRegionsLineNum"] = _scuff.RWGSurface_MaterialRegionsLineNum_get
    if _newclass:MaterialRegionsLineNum = _swig_property(_scuff.RWGSurface_MaterialRegionsLineNum_get, _scuff.RWGSurface_MaterialRegionsLineNum_set)
    __swig_setmethods__["MaterialName"] = _scuff.RWGSurface_MaterialName_set
    __swig_getmethods__["MaterialName"] = _scuff.RWGSurface_MaterialName_get
    if _newclass:MaterialName = _swig_property(_scuff.RWGSurface_MaterialName_get, _scuff.RWGSurface_MaterialName_set)
    __swig_setmethods__["TotalStraddlers"] = _scuff.RWGSurface_TotalStraddlers_set
    __swig_getmethods__["TotalStraddlers"] = _scuff.RWGSurface_TotalStraddlers_get
    if _newclass:TotalStraddlers = _swig_property(_scuff.RWGSurface_TotalStraddlers_get, _scuff.RWGSurface_TotalStraddlers_set)
    __swig_setmethods__["PhasedBFCs"] = _scuff.RWGSurface_PhasedBFCs_set
    __swig_getmethods__["PhasedBFCs"] = _scuff.RWGSurface_PhasedBFCs_get
    if _newclass:PhasedBFCs = _swig_property(_scuff.RWGSurface_PhasedBFCs_get, _scuff.RWGSurface_PhasedBFCs_set)
    def InitRWGSurface(self): return _scuff.RWGSurface_InitRWGSurface(self)
    def InitEdgeList(self): return _scuff.RWGSurface_InitEdgeList(self)
    def ReadGMSHFile(self, *args): return _scuff.RWGSurface_ReadGMSHFile(self, *args)
    def ReadComsolFile(self, *args): return _scuff.RWGSurface_ReadComsolFile(self, *args)
    def GetReducedPotentials(self, *args): return _scuff.RWGSurface_GetReducedPotentials(self, *args)
    def AddStraddlers(self, *args): return _scuff.RWGSurface_AddStraddlers(self, *args)
    def UpdateBoundingBox(self): return _scuff.RWGSurface_UpdateBoundingBox(self)
RWGSurface_swigregister = _scuff.RWGSurface_swigregister
RWGSurface_swigregister(RWGSurface)

class RWGGeometry(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, RWGGeometry, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, RWGGeometry, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _scuff.new_RWGGeometry(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _scuff.delete_RWGGeometry
    __del__ = lambda self : None;
    def AllocateBEMMatrix(self, PureImagFreq=False, Packed=False): return _scuff.RWGGeometry_AllocateBEMMatrix(self, PureImagFreq, Packed)
    def AssembleBEMMatrixBlock(self, *args): return _scuff.RWGGeometry_AssembleBEMMatrixBlock(self, *args)
    def CreateABMBAccelerator(self, *args): return _scuff.RWGGeometry_CreateABMBAccelerator(self, *args)
    def DestroyABMBAccelerator(self, *args): return _scuff.RWGGeometry_DestroyABMBAccelerator(self, *args)
    def AllocateRHSVector(self, PureImagFreq=False): return _scuff.RWGGeometry_AllocateRHSVector(self, PureImagFreq)
    def UpdateIncFields(self, *args): return _scuff.RWGGeometry_UpdateIncFields(self, *args)
    def GetFieldsGrids(self, *args): return _scuff.RWGGeometry_GetFieldsGrids(self, *args)
    def GetFieldsGrid(self, *args): return _scuff.RWGGeometry_GetFieldsGrid(self, *args)
    def GetDyadicGFs(self, *args): return _scuff.RWGGeometry_GetDyadicGFs(self, *args)
    def GetPFT(self, *args): return _scuff.RWGGeometry_GetPFT(self, *args)
    def GetPanelSourceDensities(self, *args): return _scuff.RWGGeometry_GetPanelSourceDensities(self, *args)
    def GetPanelSourceDensities2(self, *args): return _scuff.RWGGeometry_GetPanelSourceDensities2(self, *args)
    def GetDipoleMoments(self, *args): return _scuff.RWGGeometry_GetDipoleMoments(self, *args)
    def ExpandCurrentDistribution(self, *args): return _scuff.RWGGeometry_ExpandCurrentDistribution(self, *args)
    def EvalCurrentDistribution(self, *args): return _scuff.RWGGeometry_EvalCurrentDistribution(self, *args)
    def WritePPMesh(self, *args): return _scuff.RWGGeometry_WritePPMesh(self, *args)
    def WriteGPMesh(self, *args): return _scuff.RWGGeometry_WriteGPMesh(self, *args)
    def WriteGPMeshPlus(self, *args): return _scuff.RWGGeometry_WriteGPMeshPlus(self, *args)
    def PlotSurfaceCurrents(self, *args): return _scuff.RWGGeometry_PlotSurfaceCurrents(self, *args)
    def SetLogLevel(self, *args): return _scuff.RWGGeometry_SetLogLevel(self, *args)
    def SetEps(self, *args): return _scuff.RWGGeometry_SetEps(self, *args)
    def SetEpsMu(self, *args): return _scuff.RWGGeometry_SetEpsMu(self, *args)
    def GetDimension(self): return _scuff.RWGGeometry_GetDimension(self)
    def GetRegionByLabel(self, *args): return _scuff.RWGGeometry_GetRegionByLabel(self, *args)
    def GetSurfaceByLabel(self, *args): return _scuff.RWGGeometry_GetSurfaceByLabel(self, *args)
    def GetRegionIndex(self, *args): return _scuff.RWGGeometry_GetRegionIndex(self, *args)
    def PointInRegion(self, *args): return _scuff.RWGGeometry_PointInRegion(self, *args)
    def Transform(self, *args): return _scuff.RWGGeometry_Transform(self, *args)
    def UnTransform(self): return _scuff.RWGGeometry_UnTransform(self)
    def CheckGTCList(self, *args): return _scuff.RWGGeometry_CheckGTCList(self, *args)
    def AssembleBEMMatrix(self, *args): return _scuff.RWGGeometry_AssembleBEMMatrix(self, *args)
    def AssembleRHSVector(self, *args): return _scuff.RWGGeometry_AssembleRHSVector(self, *args)
    def GetFields(self, *args): return _scuff.RWGGeometry_GetFields(self, *args)
    def ProcessMEDIUMSection(self, *args): return _scuff.RWGGeometry_ProcessMEDIUMSection(self, *args)
    def ProcessLATTICESection(self, *args): return _scuff.RWGGeometry_ProcessLATTICESection(self, *args)
    def AddRegion(self, *args): return _scuff.RWGGeometry_AddRegion(self, *args)
    def UpdateCachedEpsMuValues(self, *args): return _scuff.RWGGeometry_UpdateCachedEpsMuValues(self, *args)
    def InitPBCData(self): return _scuff.RWGGeometry_InitPBCData(self)
    def CreateRegionGBA(self, *args): return _scuff.RWGGeometry_CreateRegionGBA(self, *args)
    def GetUnitCellRepresentative(self, *args): return _scuff.RWGGeometry_GetUnitCellRepresentative(self, *args)
    def GetKNCoefficients(self, *args): return _scuff.RWGGeometry_GetKNCoefficients(self, *args)
    __swig_setmethods__["NumMeshDirs"] = _scuff.RWGGeometry_NumMeshDirs_set
    __swig_getmethods__["NumMeshDirs"] = _scuff.RWGGeometry_NumMeshDirs_get
    if _newclass:NumMeshDirs = _swig_property(_scuff.RWGGeometry_NumMeshDirs_get, _scuff.RWGGeometry_NumMeshDirs_set)
    __swig_setmethods__["MeshDirs"] = _scuff.RWGGeometry_MeshDirs_set
    __swig_getmethods__["MeshDirs"] = _scuff.RWGGeometry_MeshDirs_get
    if _newclass:MeshDirs = _swig_property(_scuff.RWGGeometry_MeshDirs_get, _scuff.RWGGeometry_MeshDirs_set)
    __swig_setmethods__["NumRegions"] = _scuff.RWGGeometry_NumRegions_set
    __swig_getmethods__["NumRegions"] = _scuff.RWGGeometry_NumRegions_get
    if _newclass:NumRegions = _swig_property(_scuff.RWGGeometry_NumRegions_get, _scuff.RWGGeometry_NumRegions_set)
    __swig_setmethods__["RegionLabels"] = _scuff.RWGGeometry_RegionLabels_set
    __swig_getmethods__["RegionLabels"] = _scuff.RWGGeometry_RegionLabels_get
    if _newclass:RegionLabels = _swig_property(_scuff.RWGGeometry_RegionLabels_get, _scuff.RWGGeometry_RegionLabels_set)
    __swig_setmethods__["RegionMPs"] = _scuff.RWGGeometry_RegionMPs_set
    __swig_getmethods__["RegionMPs"] = _scuff.RWGGeometry_RegionMPs_get
    if _newclass:RegionMPs = _swig_property(_scuff.RWGGeometry_RegionMPs_get, _scuff.RWGGeometry_RegionMPs_set)
    __swig_setmethods__["EpsTF"] = _scuff.RWGGeometry_EpsTF_set
    __swig_getmethods__["EpsTF"] = _scuff.RWGGeometry_EpsTF_get
    if _newclass:EpsTF = _swig_property(_scuff.RWGGeometry_EpsTF_get, _scuff.RWGGeometry_EpsTF_set)
    __swig_setmethods__["MuTF"] = _scuff.RWGGeometry_MuTF_set
    __swig_getmethods__["MuTF"] = _scuff.RWGGeometry_MuTF_get
    if _newclass:MuTF = _swig_property(_scuff.RWGGeometry_MuTF_get, _scuff.RWGGeometry_MuTF_set)
    __swig_setmethods__["StoredOmega"] = _scuff.RWGGeometry_StoredOmega_set
    __swig_getmethods__["StoredOmega"] = _scuff.RWGGeometry_StoredOmega_get
    if _newclass:StoredOmega = _swig_property(_scuff.RWGGeometry_StoredOmega_get, _scuff.RWGGeometry_StoredOmega_set)
    __swig_setmethods__["NumSurfaces"] = _scuff.RWGGeometry_NumSurfaces_set
    __swig_getmethods__["NumSurfaces"] = _scuff.RWGGeometry_NumSurfaces_get
    if _newclass:NumSurfaces = _swig_property(_scuff.RWGGeometry_NumSurfaces_get, _scuff.RWGGeometry_NumSurfaces_set)
    __swig_setmethods__["Surfaces"] = _scuff.RWGGeometry_Surfaces_set
    __swig_getmethods__["Surfaces"] = _scuff.RWGGeometry_Surfaces_get
    if _newclass:Surfaces = _swig_property(_scuff.RWGGeometry_Surfaces_get, _scuff.RWGGeometry_Surfaces_set)
    __swig_setmethods__["AllSurfacesClosed"] = _scuff.RWGGeometry_AllSurfacesClosed_set
    __swig_getmethods__["AllSurfacesClosed"] = _scuff.RWGGeometry_AllSurfacesClosed_get
    if _newclass:AllSurfacesClosed = _swig_property(_scuff.RWGGeometry_AllSurfacesClosed_get, _scuff.RWGGeometry_AllSurfacesClosed_set)
    __swig_setmethods__["TotalBFs"] = _scuff.RWGGeometry_TotalBFs_set
    __swig_getmethods__["TotalBFs"] = _scuff.RWGGeometry_TotalBFs_get
    if _newclass:TotalBFs = _swig_property(_scuff.RWGGeometry_TotalBFs_get, _scuff.RWGGeometry_TotalBFs_set)
    __swig_setmethods__["TotalEdges"] = _scuff.RWGGeometry_TotalEdges_set
    __swig_getmethods__["TotalEdges"] = _scuff.RWGGeometry_TotalEdges_get
    if _newclass:TotalEdges = _swig_property(_scuff.RWGGeometry_TotalEdges_get, _scuff.RWGGeometry_TotalEdges_set)
    __swig_setmethods__["TotalPanels"] = _scuff.RWGGeometry_TotalPanels_set
    __swig_getmethods__["TotalPanels"] = _scuff.RWGGeometry_TotalPanels_get
    if _newclass:TotalPanels = _swig_property(_scuff.RWGGeometry_TotalPanels_get, _scuff.RWGGeometry_TotalPanels_set)
    __swig_setmethods__["AveragePanelArea"] = _scuff.RWGGeometry_AveragePanelArea_set
    __swig_getmethods__["AveragePanelArea"] = _scuff.RWGGeometry_AveragePanelArea_get
    if _newclass:AveragePanelArea = _swig_property(_scuff.RWGGeometry_AveragePanelArea_get, _scuff.RWGGeometry_AveragePanelArea_set)
    __swig_setmethods__["tolVecClose"] = _scuff.RWGGeometry_tolVecClose_set
    __swig_getmethods__["tolVecClose"] = _scuff.RWGGeometry_tolVecClose_get
    if _newclass:tolVecClose = _swig_property(_scuff.RWGGeometry_tolVecClose_get, _scuff.RWGGeometry_tolVecClose_set)
    __swig_setmethods__["Verbose"] = _scuff.RWGGeometry_Verbose_set
    __swig_getmethods__["Verbose"] = _scuff.RWGGeometry_Verbose_get
    if _newclass:Verbose = _swig_property(_scuff.RWGGeometry_Verbose_get, _scuff.RWGGeometry_Verbose_set)
    __swig_setmethods__["GeoFileName"] = _scuff.RWGGeometry_GeoFileName_set
    __swig_getmethods__["GeoFileName"] = _scuff.RWGGeometry_GeoFileName_get
    if _newclass:GeoFileName = _swig_property(_scuff.RWGGeometry_GeoFileName_get, _scuff.RWGGeometry_GeoFileName_set)
    __swig_setmethods__["LDim"] = _scuff.RWGGeometry_LDim_set
    __swig_getmethods__["LDim"] = _scuff.RWGGeometry_LDim_get
    if _newclass:LDim = _swig_property(_scuff.RWGGeometry_LDim_get, _scuff.RWGGeometry_LDim_set)
    __swig_setmethods__["LBasis"] = _scuff.RWGGeometry_LBasis_set
    __swig_getmethods__["LBasis"] = _scuff.RWGGeometry_LBasis_get
    if _newclass:LBasis = _swig_property(_scuff.RWGGeometry_LBasis_get, _scuff.RWGGeometry_LBasis_set)
    __swig_setmethods__["NumStraddlers"] = _scuff.RWGGeometry_NumStraddlers_set
    __swig_getmethods__["NumStraddlers"] = _scuff.RWGGeometry_NumStraddlers_get
    if _newclass:NumStraddlers = _swig_property(_scuff.RWGGeometry_NumStraddlers_get, _scuff.RWGGeometry_NumStraddlers_set)
    __swig_setmethods__["RegionIsExtended"] = _scuff.RWGGeometry_RegionIsExtended_set
    __swig_getmethods__["RegionIsExtended"] = _scuff.RWGGeometry_RegionIsExtended_get
    if _newclass:RegionIsExtended = _swig_property(_scuff.RWGGeometry_RegionIsExtended_get, _scuff.RWGGeometry_RegionIsExtended_set)
    __swig_setmethods__["BFIndexOffset"] = _scuff.RWGGeometry_BFIndexOffset_set
    __swig_getmethods__["BFIndexOffset"] = _scuff.RWGGeometry_BFIndexOffset_get
    if _newclass:BFIndexOffset = _swig_property(_scuff.RWGGeometry_BFIndexOffset_get, _scuff.RWGGeometry_BFIndexOffset_set)
    __swig_setmethods__["EdgeIndexOffset"] = _scuff.RWGGeometry_EdgeIndexOffset_set
    __swig_getmethods__["EdgeIndexOffset"] = _scuff.RWGGeometry_EdgeIndexOffset_get
    if _newclass:EdgeIndexOffset = _swig_property(_scuff.RWGGeometry_EdgeIndexOffset_get, _scuff.RWGGeometry_EdgeIndexOffset_set)
    __swig_setmethods__["PanelIndexOffset"] = _scuff.RWGGeometry_PanelIndexOffset_set
    __swig_getmethods__["PanelIndexOffset"] = _scuff.RWGGeometry_PanelIndexOffset_get
    if _newclass:PanelIndexOffset = _swig_property(_scuff.RWGGeometry_PanelIndexOffset_get, _scuff.RWGGeometry_PanelIndexOffset_set)
    __swig_setmethods__["Mate"] = _scuff.RWGGeometry_Mate_set
    __swig_getmethods__["Mate"] = _scuff.RWGGeometry_Mate_get
    if _newclass:Mate = _swig_property(_scuff.RWGGeometry_Mate_get, _scuff.RWGGeometry_Mate_set)
    __swig_setmethods__["SurfaceMoved"] = _scuff.RWGGeometry_SurfaceMoved_set
    __swig_getmethods__["SurfaceMoved"] = _scuff.RWGGeometry_SurfaceMoved_get
    if _newclass:SurfaceMoved = _swig_property(_scuff.RWGGeometry_SurfaceMoved_get, _scuff.RWGGeometry_SurfaceMoved_set)
    __swig_setmethods__["LogLevel"] = _scuff.RWGGeometry_LogLevel_set
    __swig_getmethods__["LogLevel"] = _scuff.RWGGeometry_LogLevel_get
    if _newclass:LogLevel = _swig_property(_scuff.RWGGeometry_LogLevel_get, _scuff.RWGGeometry_LogLevel_set)
    __swig_setmethods__["TBlockCacheNameAddendum"] = _scuff.RWGGeometry_TBlockCacheNameAddendum_set
    __swig_getmethods__["TBlockCacheNameAddendum"] = _scuff.RWGGeometry_TBlockCacheNameAddendum_get
    if _newclass:TBlockCacheNameAddendum = _swig_property(_scuff.RWGGeometry_TBlockCacheNameAddendum_get, _scuff.RWGGeometry_TBlockCacheNameAddendum_set)
    __swig_setmethods__["AssignBasisFunctionsToExteriorEdges"] = _scuff.RWGGeometry_AssignBasisFunctionsToExteriorEdges_set
    __swig_getmethods__["AssignBasisFunctionsToExteriorEdges"] = _scuff.RWGGeometry_AssignBasisFunctionsToExteriorEdges_get
    if _newclass:AssignBasisFunctionsToExteriorEdges = _swig_property(_scuff.RWGGeometry_AssignBasisFunctionsToExteriorEdges_get, _scuff.RWGGeometry_AssignBasisFunctionsToExteriorEdges_set)
    __swig_setmethods__["UseHighKTaylorDuffy"] = _scuff.RWGGeometry_UseHighKTaylorDuffy_set
    __swig_getmethods__["UseHighKTaylorDuffy"] = _scuff.RWGGeometry_UseHighKTaylorDuffy_get
    if _newclass:UseHighKTaylorDuffy = _swig_property(_scuff.RWGGeometry_UseHighKTaylorDuffy_get, _scuff.RWGGeometry_UseHighKTaylorDuffy_set)
    __swig_setmethods__["UseGetFieldsV2P0"] = _scuff.RWGGeometry_UseGetFieldsV2P0_set
    __swig_getmethods__["UseGetFieldsV2P0"] = _scuff.RWGGeometry_UseGetFieldsV2P0_get
    if _newclass:UseGetFieldsV2P0 = _swig_property(_scuff.RWGGeometry_UseGetFieldsV2P0_get, _scuff.RWGGeometry_UseGetFieldsV2P0_set)
    __swig_setmethods__["UseTaylorDuffyV2P0"] = _scuff.RWGGeometry_UseTaylorDuffyV2P0_set
    __swig_getmethods__["UseTaylorDuffyV2P0"] = _scuff.RWGGeometry_UseTaylorDuffyV2P0_get
    if _newclass:UseTaylorDuffyV2P0 = _swig_property(_scuff.RWGGeometry_UseTaylorDuffyV2P0_get, _scuff.RWGGeometry_UseTaylorDuffyV2P0_set)
    __swig_setmethods__["DisableCache"] = _scuff.RWGGeometry_DisableCache_set
    __swig_getmethods__["DisableCache"] = _scuff.RWGGeometry_DisableCache_get
    if _newclass:DisableCache = _swig_property(_scuff.RWGGeometry_DisableCache_get, _scuff.RWGGeometry_DisableCache_set)
RWGGeometry_swigregister = _scuff.RWGGeometry_swigregister
RWGGeometry_swigregister(RWGGeometry)


def NewRWGPanel(*args):
  return _scuff.NewRWGPanel(*args)
NewRWGPanel = _scuff.NewRWGPanel

def InitRWGPanel(*args):
  return _scuff.InitRWGPanel(*args)
InitRWGPanel = _scuff.InitRWGPanel

def CountCommonRegions(*args):
  return _scuff.CountCommonRegions(*args)
CountCommonRegions = _scuff.CountCommonRegions

def VecZero(*args):
  return _scuff.VecZero(*args)
VecZero = _scuff.VecZero

def VecCopy(*args):
  return _scuff.VecCopy(*args)
VecCopy = _scuff.VecCopy

def VecScaleAdd(*args):
  return _scuff.VecScaleAdd(*args)
VecScaleAdd = _scuff.VecScaleAdd

def VecAdd(*args):
  return _scuff.VecAdd(*args)
VecAdd = _scuff.VecAdd

def VecSub(*args):
  return _scuff.VecSub(*args)
VecSub = _scuff.VecSub

def VecCross(*args):
  return _scuff.VecCross(*args)
VecCross = _scuff.VecCross

def VecLinComb(*args):
  return _scuff.VecLinComb(*args)
VecLinComb = _scuff.VecLinComb

def VecDot(*args):
  return _scuff.VecDot(*args)
VecDot = _scuff.VecDot

def VecDistance(*args):
  return _scuff.VecDistance(*args)
VecDistance = _scuff.VecDistance

def VecDistance2(*args):
  return _scuff.VecDistance2(*args)
VecDistance2 = _scuff.VecDistance2

def VecNorm(*args):
  return _scuff.VecNorm(*args)
VecNorm = _scuff.VecNorm

def VecNorm2(*args):
  return _scuff.VecNorm2(*args)
VecNorm2 = _scuff.VecNorm2

def VecNormalize(*args):
  return _scuff.VecNormalize(*args)
VecNormalize = _scuff.VecNormalize

def EqualFloat(*args):
  return _scuff.EqualFloat(*args)
EqualFloat = _scuff.EqualFloat

def VecEqualFloat(*args):
  return _scuff.VecEqualFloat(*args)
VecEqualFloat = _scuff.VecEqualFloat

def VecClose(*args):
  return _scuff.VecClose(*args)
VecClose = _scuff.VecClose

def SixVecPlus(*args):
  return _scuff.SixVecPlus(*args)
SixVecPlus = _scuff.SixVecPlus

def SixVecPlusEquals(*args):
  return _scuff.SixVecPlusEquals(*args)
SixVecPlusEquals = _scuff.SixVecPlusEquals

def Matrix2x2_Inverse(*args):
  return _scuff.Matrix2x2_Inverse(*args)
Matrix2x2_Inverse = _scuff.Matrix2x2_Inverse

def CreateGammaMatrix(*args):
  return _scuff.CreateGammaMatrix(*args)
CreateGammaMatrix = _scuff.CreateGammaMatrix

def PreloadCache(*args):
  return _scuff.PreloadCache(*args)
PreloadCache = _scuff.PreloadCache

def StoreCache(*args):
  return _scuff.StoreCache(*args)
StoreCache = _scuff.StoreCache
# This file is compatible with both classic and new-style classes.


